kysely 0.24.1 → 0.25.0

package/dist/cjs/util/type-utils.d.ts

@@ -2,10 +2,7 @@ import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { InsertResult } from '../query-builder/insert-result.js';
 import { DeleteResult } from '../query-builder/delete-result.js';
 import { UpdateResult } from '../query-builder/update-result.js';
-/**
- * Given an object type, extracts the union of all value types.
- */
-export declare type ValueType<T> = T[keyof T];
+import { KyselyTypeError } from './type-error.js';
 /**
  * Given a database type and a union of table names in that db, returns
  * a union type with all possible column names.
@@ -37,9 +34,9 @@ export declare type ValueType<T> = T[keyof T];
  * // Columns == 'id' | 'name' | 'species'
  * ```
  */
-export declare type AnyColumn<DB, TB extends keyof DB> = {
+export declare type AnyColumn<DB, TB extends keyof DB> = DrainOuterGeneric<{
     [T in TB]: keyof DB[T];
-}[TB] & string;
+}[TB] & string>;
 /**
  * Extracts a column type.
  */
@@ -102,9 +99,9 @@ export declare type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : ne
 export declare type AnySelectQueryBuilder = SelectQueryBuilder<any, any, any>;
 export declare type SimplifySingleResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : Simplify<O> | undefined;
 export declare type SimplifyResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : Simplify<O>;
-export declare type Simplify<T> = {
+export declare type Simplify<T> = DrainOuterGeneric<{
     [K in keyof T]: T[K];
-} & {};
+} & {}>;
 /**
  * Represents a database row whose column names and their types are unknown.
  */
@@ -115,33 +112,50 @@ export declare type UnknownRow = Record<string, unknown>;
 export declare type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
-/**
- * Takes all properties from T1 and merges all properties from T2
- * that don't exist in T1 as optional properties.
- *
- * Example:
- *
- * interface Person {
- *   name: string
- *   age: number
- * }
- *
- * interface Pet {
- *   name: string
- *   species: 'cat' | 'dog'
- * }
- *
- * type Merged = MergePartial<Person, Pet>
- *
- * // { name: string, age: number, species?: 'cat' | 'dog' }
- */
-export declare type MergePartial<T1, T2> = T1 & Partial<Omit<T2, keyof T1>>;
 /**
  * Evaluates to `true` if `T` is `never`.
  */
 export declare type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Evaluates to `true` if `T` is `any`.
+ */
+export declare type IsAny<T> = 0 extends T & 1 ? true : false;
 /**
  * Evaluates to `true` if the types `T` and `U` are equal.
  */
 export declare type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
+export declare type NarrowPartial<S, T> = DrainOuterGeneric<{
+    [K in keyof S & string]: K extends keyof T ? T[K] extends S[K] ? T[K] : KyselyTypeError<`$narrowType() call failed: passed type does not exist in '${K}'s type union`> : S[K];
+}>;
 export declare type SqlBool = boolean | 0 | 1;
+/**
+ * Utility to reduce depth of TypeScript's internal type instantiation stack.
+ *
+ * Example:
+ *
+ * ```ts
+ * type A<T> = { item: T }
+ *
+ * type Test<T> = A<
+ *   A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<T>>>>>>>>>>>>>>>>>>>>>>>>
+ * >
+ *
+ * type Error = Test<number> // Type instantiation is excessively deep and possibly infinite.ts (2589)
+ * ```
+ *
+ * To fix this, we can use `DrainOuterGeneric`:
+ *
+ * ```ts
+ * type A<T> = DrainOuterGeneric<{ item: T }>
+ *
+ * type Test<T> = A<
+ *  A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<T>>>>>>>>>>>>>>>>>>>>>>>>
+ * >
+ *
+ * type Ok = Test<number> // Ok
+ * ```
+ */
+export declare type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
+export declare type ShallowRecord<K extends keyof any, T> = DrainOuterGeneric<{
+    [P in K]: T;
+}>;

package/dist/esm/dialect/mysql/mysql-dialect-config.d.ts

@@ -1,4 +1,5 @@
 import { DatabaseConnection } from '../../driver/database-connection.js';
+import { ShallowRecord } from '../../util/type-utils.js';
 /**
  * Config for the MySQL dialect.
  *
@@ -48,4 +49,4 @@ export interface MysqlOkPacket {
     affectedRows: number;
     insertId: number;
 }
-export declare type MysqlQueryResult = MysqlOkPacket | Record<string, unknown>[];
+export declare type MysqlQueryResult = MysqlOkPacket | ShallowRecord<string, unknown>[];

package/dist/esm/dialect/postgres/postgres-introspector.js

@@ -48,7 +48,10 @@ export class PostgresIntrospector {
                 .as('auto_incrementing'),
         ])
             // r == normal table
-            .where('c.relkind', 'in', ['r', 'v'])
+            .where(({ cmpr, or }) => or([
+            cmpr('c.relkind', '=', 'r'),
+            cmpr('c.relkind', '=', 'v'),
+        ]))
             .where('ns.nspname', '!~', '^pg_')
             .where('ns.nspname', '!=', 'information_schema')
             // No system columns

package/dist/esm/driver/runtime-driver.js

@@ -74,24 +74,24 @@ export class RuntimeDriver {
                 return await executeQuery.call(connection, compiledQuery);
             }
             catch (error) {
-                this.#logError(error, compiledQuery, startTime);
+                await this.#logError(error, compiledQuery, startTime);
                 throw error;
             }
             finally {
-                this.#logQuery(compiledQuery, startTime);
+                await this.#logQuery(compiledQuery, startTime);
             }
         };
     }
-    #logError(error, compiledQuery, startTime) {
-        this.#log.error(() => ({
+    async #logError(error, compiledQuery, startTime) {
+        await this.#log.error(() => ({
             level: 'error',
             error,
             query: compiledQuery,
             queryDurationMillis: this.#calculateDurationMillis(startTime),
         }));
     }
-    #logQuery(compiledQuery, startTime) {
-        this.#log.query(() => ({
+    async #logQuery(compiledQuery, startTime) {
+        await this.#log.query(() => ({
             level: 'query',
             query: compiledQuery,
             queryDurationMillis: this.#calculateDurationMillis(startTime),

package/dist/esm/dynamic/dynamic.d.ts

@@ -69,7 +69,7 @@ export declare class DynamicModule {
      *
      * const [person] = await db.selectFrom('person')
      *   .select([
-     *     ref<PossibleColumns>(columnFromUserInput)
+     *     ref<PossibleColumns>(columnFromUserInput),
      *     'id'
      *   ])
      *   .execute()

package/dist/esm/dynamic/dynamic.js

@@ -70,7 +70,7 @@ export class DynamicModule {
      *
      * const [person] = await db.selectFrom('person')
      *   .select([
-     *     ref<PossibleColumns>(columnFromUserInput)
+     *     ref<PossibleColumns>(columnFromUserInput),
      *     'id'
      *   ])
      *   .execute()

package/dist/esm/expression/expression-builder.d.ts

@@ -1,7 +1,7 @@
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { TableExpression, From, FromTables, ExtractTableAlias, AnyAliasedTable, PickTableWithAlias } from '../parser/table-parser.js';
 import { FunctionModule } from '../query-builder/function-module.js';
-import { ExtractTypeFromReferenceExpression, ReferenceExpression, StringReference } from '../parser/reference-parser.js';
+import { ExtractTypeFromReferenceExpression, ReferenceExpression, SimpleReferenceExpression, StringReference } from '../parser/reference-parser.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { BinaryOperatorExpression, ComparisonOperatorExpression, OperandValueExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { Expression } from './expression.js';
@@ -9,6 +9,7 @@ import { ExpressionWrapper } from './expression-wrapper.js';
 import { ComparisonOperator, UnaryOperator } from '../operation-node/operator-node.js';
 import { SqlBool } from '../util/type-utils.js';
 import { ExtractTypeFromValueExpressionOrList } from '../parser/value-parser.js';
+import { CaseBuilder } from '../query-builder/case-builder.js';
 export interface ExpressionBuilder<DB, TB extends keyof DB> {
     /**
      * Returns a {@link FunctionModule} that can be used to write type safe function
@@ -91,6 +92,60 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
     selectFrom<TE extends keyof DB & string>(from: TE): SelectQueryBuilder<DB, TB | ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends AnyAliasedTable<DB>>(from: TE): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, TB | ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends TableExpression<DB, TB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
+    /**
+     * Creates a `case` statement/operator.
+     *
+     * ### Examples
+     *
+     * Kitchen sink example with 2 flavors of `case` operator:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const { title, name } = await db
+     *   .selectFrom('person')
+     *   .where('id', '=', '123')
+     *   .select((eb) => [
+     *     eb.fn.coalesce('last_name', 'first_name').as('name'),
+     *     eb
+     *       .case()
+     *       .when('gender', '=', 'male')
+     *       .then('Mr.')
+     *       .when('gender', '=', 'female')
+     *       .then(
+     *         eb
+     *           .case('martialStatus')
+     *           .when('single')
+     *           .then('Ms.')
+     *           .else('Mrs.')
+     *           .end()
+     *       )
+     *       .end()
+     *       .as('title'),
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select
+     *   coalesce("last_name", "first_name") as "name",
+     *   case
+     *     when "gender" = $1 then $2
+     *     when "gender" = $3 then
+     *       case "martialStatus"
+     *         when $4 then $5
+     *         else $6
+     *       end
+     *   end as "title"
+     * from "person"
+     * where "id" = $7
+     * ```
+     */
+    case(): CaseBuilder<DB, TB>;
+    case<C extends SimpleReferenceExpression<DB, TB>>(column: C): CaseBuilder<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, C>>;
+    case<O>(expression: Expression<O>): CaseBuilder<DB, TB, O>;
     /**
      * This can be used to reference columns.
      *

package/dist/esm/expression/expression-builder.js

@@ -5,7 +5,7 @@ import { parseTableExpressionOrList, } from '../parser/table-parser.js';
 import { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';
 import { createQueryId } from '../util/query-id.js';
 import { createFunctionModule, } from '../query-builder/function-module.js';
-import { parseStringReference, } from '../parser/reference-parser.js';
+import { parseReferenceExpression, parseStringReference, } from '../parser/reference-parser.js';
 import { parseValueBinaryOperation, } from '../parser/binary-operation-parser.js';
 import { AndNode } from '../operation-node/and-node.js';
 import { OrNode } from '../operation-node/or-node.js';
@@ -15,6 +15,9 @@ import { parseUnaryOperation } from '../parser/unary-operation-parser.js';
 import { parseValueExpressionOrList, } from '../parser/value-parser.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
 import { ValueNode } from '../operation-node/value-node.js';
+import { CaseBuilder } from '../query-builder/case-builder.js';
+import { CaseNode } from '../operation-node/case-node.js';
+import { isUndefined } from '../util/object-utils.js';
 export function createExpressionBuilder(executor = NOOP_QUERY_EXECUTOR) {
     function unary(op, expr) {
         return new ExpressionWrapper(parseUnaryOperation(op, expr));
@@ -30,6 +33,13 @@ export function createExpressionBuilder(executor = NOOP_QUERY_EXECUTOR) {
                 queryNode: SelectQueryNode.create(parseTableExpressionOrList(table)),
             });
         },
+        case(reference) {
+            return new CaseBuilder({
+                node: CaseNode.create(isUndefined(reference)
+                    ? undefined
+                    : parseReferenceExpression(reference)),
+            });
+        },
         ref(reference) {
             return new ExpressionWrapper(parseStringReference(reference));
         },

package/dist/esm/helpers/mysql.d.ts

@@ -3,7 +3,7 @@ import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { Simplify } from '../util/type-utils.js';
 /**
- * A MySQL helper for aggregating a subquery (or other expression) into a JSON array.
+ * A MySQL helper for aggregating a subquery into a JSON array.
  *
  * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
  * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
@@ -49,7 +49,7 @@ import { Simplify } from '../util/type-utils.js';
  */
 export declare function jsonArrayFrom<O>(expr: SelectQueryBuilder<any, any, O>): RawBuilder<Simplify<O>[]>;
 /**
- * A MySQL helper for turning a subquery (or other expression) into a JSON object.
+ * A MySQL helper for turning a subquery into a JSON object.
  *
  * The subquery must only return one row.
  *
@@ -95,7 +95,7 @@ export declare function jsonArrayFrom<O>(expr: SelectQueryBuilder<any, any, O>):
  * from `person`
  * ```
  */
-export declare function jsonObjectFrom<O>(expr: SelectQueryBuilder<any, any, O>): RawBuilder<Simplify<O>>;
+export declare function jsonObjectFrom<O>(expr: SelectQueryBuilder<any, any, O>): RawBuilder<Simplify<O> | null>;
 /**
  * The MySQL `json_object` function.
  *

package/dist/esm/helpers/mysql.js

@@ -5,7 +5,7 @@ import { IdentifierNode } from '../operation-node/identifier-node.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
 import { sql } from '../raw-builder/sql.js';
 /**
- * A MySQL helper for aggregating a subquery (or other expression) into a JSON array.
+ * A MySQL helper for aggregating a subquery into a JSON array.
  *
  * NOTE: This helper is only guaranteed to fully work with the built-in `MysqlDialect`.
  * While the produced SQL is compatibe with all MySQL databases, some 3rd party dialects
@@ -53,7 +53,7 @@ export function jsonArrayFrom(expr) {
     return sql `(select cast(coalesce(json_arrayagg(json_object(${sql.join(getJsonObjectArgs(expr.toOperationNode(), 'agg'))})), '[]') as json) from ${expr} as agg)`;
 }
 /**
- * A MySQL helper for turning a subquery (or other expression) into a JSON object.
+ * A MySQL helper for turning a subquery into a JSON object.
  *
  * The subquery must only return one row.
  *

package/dist/esm/helpers/postgres.d.ts

@@ -88,7 +88,7 @@ export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simpli
  * from "person"
  * ```
  */
-export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O>>;
+export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O> | null>;
 /**
  * The PostgreSQL `json_build_object` function.
  *

package/dist/esm/index.d.ts

@@ -2,6 +2,7 @@ export * from './kysely.js';
 export * from './query-creator.js';
 export * from './expression/expression.js';
 export { ExpressionBuilder, expressionBuilder, } from './expression/expression-builder.js';
+export * from './expression/expression-wrapper.js';
 export * from './query-builder/where-interface.js';
 export * from './query-builder/returning-interface.js';
 export * from './query-builder/having-interface.js';
@@ -17,6 +18,7 @@ export * from './query-builder/delete-result.js';
 export * from './query-builder/update-result.js';
 export * from './query-builder/on-conflict-builder.js';
 export * from './query-builder/aggregate-function-builder.js';
+export * from './query-builder/case-builder.js';
 export * from './raw-builder/raw-builder.js';
 export * from './raw-builder/sql.js';
 export * from './query-executor/query-executor.js';
@@ -83,6 +85,7 @@ export * from './operation-node/alias-node.js';
 export * from './operation-node/alter-column-node.js';
 export * from './operation-node/alter-table-node.js';
 export * from './operation-node/and-node.js';
+export * from './operation-node/case-node.js';
 export * from './operation-node/check-constraint-node.js';
 export * from './operation-node/column-definition-node.js';
 export * from './operation-node/column-node.js';
@@ -148,6 +151,7 @@ export * from './operation-node/update-query-node.js';
 export * from './operation-node/value-list-node.js';
 export * from './operation-node/value-node.js';
 export * from './operation-node/values-node.js';
+export * from './operation-node/when-node.js';
 export * from './operation-node/where-node.js';
 export * from './operation-node/with-node.js';
 export * from './operation-node/explain-node.js';

package/dist/esm/index.js

@@ -3,6 +3,7 @@ export * from './kysely.js';
 export * from './query-creator.js';
 export * from './expression/expression.js';
 export { expressionBuilder, } from './expression/expression-builder.js';
+export * from './expression/expression-wrapper.js';
 export * from './query-builder/where-interface.js';
 export * from './query-builder/returning-interface.js';
 export * from './query-builder/having-interface.js';
@@ -18,6 +19,7 @@ export * from './query-builder/delete-result.js';
 export * from './query-builder/update-result.js';
 export * from './query-builder/on-conflict-builder.js';
 export * from './query-builder/aggregate-function-builder.js';
+export * from './query-builder/case-builder.js';
 export * from './raw-builder/raw-builder.js';
 export * from './raw-builder/sql.js';
 export * from './query-executor/query-executor.js';
@@ -84,6 +86,7 @@ export * from './operation-node/alias-node.js';
 export * from './operation-node/alter-column-node.js';
 export * from './operation-node/alter-table-node.js';
 export * from './operation-node/and-node.js';
+export * from './operation-node/case-node.js';
 export * from './operation-node/check-constraint-node.js';
 export * from './operation-node/column-definition-node.js';
 export * from './operation-node/column-node.js';
@@ -149,6 +152,7 @@ export * from './operation-node/update-query-node.js';
 export * from './operation-node/value-list-node.js';
 export * from './operation-node/value-node.js';
 export * from './operation-node/values-node.js';
+export * from './operation-node/when-node.js';
 export * from './operation-node/where-node.js';
 export * from './operation-node/with-node.js';
 export * from './operation-node/explain-node.js';

package/dist/esm/kysely.d.ts

@@ -13,6 +13,8 @@ import { QueryResult } from './driver/database-connection.js';
 import { CompiledQuery } from './query-compiler/compiled-query.js';
 import { QueryId } from './util/query-id.js';
 import { Compilable } from './util/compilable.js';
+import { CaseBuilder } from './query-builder/case-builder.js';
+import { Expression } from './expression/expression.js';
 /**
  * The main Kysely class.
  *
@@ -75,6 +77,13 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      * Returns a {@link DatabaseIntrospector | database introspector}.
      */
     get introspection(): DatabaseIntrospector;
+    /**
+     * Creates a `case` statement/operator.
+     *
+     * See {@link ExpressionBuilder.case} for more information.
+     */
+    case(): CaseBuilder<DB, keyof DB>;
+    case<V>(value: Expression<V>): CaseBuilder<DB, keyof DB, V>;
     /**
      * Returns a {@link FunctionModule} that can be used to write type safe function
      * calls.
@@ -138,7 +147,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      *       name: 'Catto',
      *       species: 'cat'
      *     })
-     *     .returning('*')
+     *     .returningAll()
      *     .executeTakeFirst()
      * })
      * ```
@@ -180,6 +189,10 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      * Returns a copy of this Kysely instance without any plugins.
      */
     withoutPlugins(): Kysely<DB>;
+    /**
+     * @override
+     */
+    withSchema(schema: string): Kysely<DB>;
     /**
      * Returns a copy of this Kysely instance with tables added to its
      * database type.
@@ -279,7 +292,7 @@ export declare class Transaction<DB> extends Kysely<DB> {
      *       name: 'Catto',
      *       species: 'cat'
      *     })
-     *     .returning('*')
+     *     .returningAll()
      *     .executeTakeFirst()
      * })
      * ```
@@ -327,6 +340,10 @@ export declare class Transaction<DB> extends Kysely<DB> {
      * Returns a copy of this Kysely instance without any plugins.
      */
     withoutPlugins(): Transaction<DB>;
+    /**
+     * @override
+     */
+    withSchema(schema: string): Transaction<DB>;
     /**
      * Returns a copy of this Kysely instance with tables added to its
      * database type.

package/dist/esm/kysely.js

@@ -4,7 +4,7 @@ import { DynamicModule } from './dynamic/dynamic.js';
 import { DefaultConnectionProvider } from './driver/default-connection-provider.js';
 import { QueryCreator } from './query-creator.js';
 import { DefaultQueryExecutor } from './query-executor/default-query-executor.js';
-import { freeze, isObject } from './util/object-utils.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';
@@ -13,6 +13,10 @@ import { createFunctionModule, } from './query-builder/function-module.js';
 import { Log } from './util/log.js';
 import { createQueryId } from './util/query-id.js';
 import { isCompilable } from './util/compilable.js';
+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';
 /**
  * The main Kysely class.
  *
@@ -106,6 +110,11 @@ export class Kysely extends QueryCreator {
     get introspection() {
         return this.#props.dialect.createIntrospector(this.withoutPlugins());
     }
+    case(value) {
+        return new CaseBuilder({
+            node: CaseNode.create(isUndefined(value) ? undefined : parseExpression(value)),
+        });
+    }
     /**
      * Returns a {@link FunctionModule} that can be used to write type safe function
      * calls.
@@ -171,7 +180,7 @@ export class Kysely extends QueryCreator {
      *       name: 'Catto',
      *       species: 'cat'
      *     })
-     *     .returning('*')
+     *     .returningAll()
      *     .executeTakeFirst()
      * })
      * ```
@@ -227,6 +236,15 @@ export class Kysely extends QueryCreator {
             executor: this.#props.executor.withoutPlugins(),
         });
     }
+    /**
+     * @override
+     */
+    withSchema(schema) {
+        return new Kysely({
+            ...this.#props,
+            executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema)),
+        });
+    }
     /**
      * Returns a copy of this Kysely instance with tables added to its
      * database type.
@@ -327,6 +345,15 @@ export class Transaction extends Kysely {
             executor: this.#props.executor.withoutPlugins(),
         });
     }
+    /**
+     * @override
+     */
+    withSchema(schema) {
+        return new Transaction({
+            ...this.#props,
+            executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema)),
+        });
+    }
     withTables() {
         return new Transaction({ ...this.#props });
     }

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

@@ -1,13 +1,10 @@
 import { OperationNode } from './operation-node.js';
 import { OverNode } from './over-node.js';
-import { SelectionNode } from './selection-node.js';
-import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
 import { WhereNode } from './where-node.js';
-declare type AggregateFunction = 'avg' | 'count' | 'max' | 'min' | 'sum';
 export interface AggregateFunctionNode extends OperationNode {
     readonly kind: 'AggregateFunctionNode';
-    readonly func: AggregateFunction;
-    readonly aggregated: SimpleReferenceExpressionNode | SelectionNode;
+    readonly func: string;
+    readonly aggregated: readonly OperationNode[];
     readonly distinct?: boolean;
     readonly filter?: WhereNode;
     readonly over?: OverNode;
@@ -17,10 +14,9 @@ export interface AggregateFunctionNode extends OperationNode {
  */
 export declare const AggregateFunctionNode: Readonly<{
     is(node: OperationNode): node is AggregateFunctionNode;
-    create(aggregateFunction: AggregateFunction, aggregated: SimpleReferenceExpressionNode | SelectionNode): AggregateFunctionNode;
+    create(aggregateFunction: string, aggregated?: readonly OperationNode[]): AggregateFunctionNode;
     cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
     cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOver(aggregateFunctionNode: AggregateFunctionNode, over?: OverNode): AggregateFunctionNode;
 }>;
-export {};

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

@@ -8,7 +8,7 @@ export const AggregateFunctionNode = freeze({
     is(node) {
         return node.kind === 'AggregateFunctionNode';
     },
-    create(aggregateFunction, aggregated) {
+    create(aggregateFunction, aggregated = []) {
         return freeze({
             kind: 'AggregateFunctionNode',
             func: aggregateFunction,

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

@@ -1,12 +1,11 @@
 import { OperationNode } from './operation-node.js';
 import { ColumnNode } from './column-node.js';
-import { DataTypeNode } from './data-type-node.js';
 import { RawNode } from './raw-node.js';
 export declare type AlterColumnNodeProps = Omit<AlterColumnNode, 'kind' | 'column'>;
 export interface AlterColumnNode extends OperationNode {
     readonly kind: 'AlterColumnNode';
     readonly column: ColumnNode;
-    readonly dataType?: DataTypeNode;
+    readonly dataType?: OperationNode;
     readonly dataTypeExpression?: RawNode;
     readonly setDefault?: OperationNode;
     readonly dropDefault?: true;

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

@@ -24,7 +24,7 @@ export interface AlterTableNode extends OperationNode {
  */
 export declare const AlterTableNode: Readonly<{
     is(node: OperationNode): node is AlterTableNode;
-    create(table: string): AlterTableNode;
+    create(table: TableNode): AlterTableNode;
     cloneWithTableProps(node: AlterTableNode, props: AlterTableNodeTableProps): AlterTableNode;
     cloneWithColumnAlteration(node: AlterTableNode, columnAlteration: AlterTableColumnAlterationNode): AlterTableNode;
 }>;

package/dist/esm/operation-node/alter-table-node.js

@@ -1,6 +1,5 @@
 /// <reference types="./alter-table-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
-import { TableNode } from './table-node.js';
 /**
  * @internal
  */
@@ -11,7 +10,7 @@ export const AlterTableNode = freeze({
     create(table) {
         return freeze({
             kind: 'AlterTableNode',
-            table: TableNode.create(table),
+            table,
         });
     },
     cloneWithTableProps(node, props) {

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

@@ -0,0 +1,19 @@
+import { OperationNode } from './operation-node.js';
+import { WhenNode } from './when-node.js';
+export interface CaseNode extends OperationNode {
+    readonly kind: 'CaseNode';
+    readonly value?: OperationNode;
+    readonly when?: ReadonlyArray<WhenNode>;
+    readonly else?: OperationNode;
+    readonly isStatement?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const CaseNode: Readonly<{
+    is(node: OperationNode): node is CaseNode;
+    create(value?: OperationNode): CaseNode;
+    cloneWithWhen(caseNode: CaseNode, when: WhenNode): CaseNode;
+    cloneWithThen(caseNode: CaseNode, then: OperationNode): CaseNode;
+    cloneWith(caseNode: CaseNode, props: Partial<Pick<CaseNode, 'else' | 'isStatement'>>): CaseNode;
+}>;