kysely 0.27.5 → 0.28.0

package/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists-transformer.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandleEmptyInListsTransformer = void 0;
+const operation_node_transformer_js_1 = require("../../operation-node/operation-node-transformer.js");
+const primitive_value_list_node_js_1 = require("../../operation-node/primitive-value-list-node.js");
+const operator_node_js_1 = require("../../operation-node/operator-node.js");
+const value_list_node_js_1 = require("../../operation-node/value-list-node.js");
+class HandleEmptyInListsTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {
+    #strategy;
+    constructor(strategy) {
+        super();
+        this.#strategy = strategy;
+    }
+    transformBinaryOperation(node) {
+        if (this.#isEmptyInListNode(node)) {
+            return this.#strategy(node);
+        }
+        return node;
+    }
+    #isEmptyInListNode(node) {
+        const { operator, rightOperand } = node;
+        return ((primitive_value_list_node_js_1.PrimitiveValueListNode.is(rightOperand) ||
+            value_list_node_js_1.ValueListNode.is(rightOperand)) &&
+            rightOperand.values.length === 0 &&
+            operator_node_js_1.OperatorNode.is(operator) &&
+            (operator.operator === 'in' || operator.operator === 'not in'));
+    }
+}
+exports.HandleEmptyInListsTransformer = HandleEmptyInListsTransformer;

package/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists.d.ts

@@ -0,0 +1,44 @@
+import { BinaryOperationNode } from '../../operation-node/binary-operation-node.js';
+import { OperatorNode } from '../../operation-node/operator-node.js';
+import { PrimitiveValueListNode } from '../../operation-node/primitive-value-list-node.js';
+import { ValueListNode } from '../../operation-node/value-list-node.js';
+export interface HandleEmptyInListsOptions {
+    /**
+     * The strategy to use when handling `in ()` and `not in ()`.
+     *
+     * See {@link HandleEmptyInListsPlugin} for examples.
+     */
+    strategy: EmptyInListsStrategy;
+}
+export type EmptyInListNode = BinaryOperationNode & {
+    operator: OperatorNode & {
+        operator: 'in' | 'not in';
+    };
+    rightOperand: (ValueListNode | PrimitiveValueListNode) & {
+        values: Readonly<[]>;
+    };
+};
+export type EmptyInListsStrategy = (node: EmptyInListNode) => BinaryOperationNode;
+/**
+ * Replaces the `in`/`not in` expression with a noncontingent expression (always true or always
+ * false) depending on the original operator.
+ *
+ * This is how Knex.js, PrismaORM, Laravel, and SQLAlchemy handle `in ()` and `not in ()`.
+ *
+ * See {@link pushValueIntoList} for an alternative strategy.
+ */
+export declare function replaceWithNoncontingentExpression(node: EmptyInListNode): BinaryOperationNode;
+/**
+ * When `in`, pushes a `null` value into the list resulting in `in (null)`. This
+ * is how TypeORM and Sequelize handle `in ()`. `in (null)` is logically the equivalent
+ * of `= null`, which returns `null`, which is a falsy expression in most SQL databases.
+ * We recommend NOT using this strategy if you plan to use `in` in `select`, `returning`,
+ * or `output` clauses, as the return type differs from the `SqlBool` default type.
+ *
+ * When `not in`, casts the left operand as `char` and pushes a literal value into
+ * the list resulting in `cast({{lhs}} as char) not in ({{VALUE}})`. Casting
+ * is required to avoid database errors with non-string columns.
+ *
+ * See {@link replaceWithNoncontingentExpression} for an alternative strategy.
+ */
+export declare function pushValueIntoList(uniqueNotInLiteral: '__kysely_no_values_were_provided__' | (string & {})): EmptyInListsStrategy;

package/dist/cjs/plugin/handle-empty-in-lists/handle-empty-in-lists.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceWithNoncontingentExpression = replaceWithNoncontingentExpression;
+exports.pushValueIntoList = pushValueIntoList;
+const binary_operation_node_js_1 = require("../../operation-node/binary-operation-node.js");
+const cast_node_js_1 = require("../../operation-node/cast-node.js");
+const data_type_node_js_1 = require("../../operation-node/data-type-node.js");
+const operator_node_js_1 = require("../../operation-node/operator-node.js");
+const value_list_node_js_1 = require("../../operation-node/value-list-node.js");
+const value_node_js_1 = require("../../operation-node/value-node.js");
+const object_utils_js_1 = require("../../util/object-utils.js");
+let contradiction;
+let eq;
+let one;
+let tautology;
+/**
+ * Replaces the `in`/`not in` expression with a noncontingent expression (always true or always
+ * false) depending on the original operator.
+ *
+ * This is how Knex.js, PrismaORM, Laravel, and SQLAlchemy handle `in ()` and `not in ()`.
+ *
+ * See {@link pushValueIntoList} for an alternative strategy.
+ */
+function replaceWithNoncontingentExpression(node) {
+    const _one = (one ||= value_node_js_1.ValueNode.createImmediate(1));
+    const _eq = (eq ||= operator_node_js_1.OperatorNode.create('='));
+    if (node.operator.operator === 'in') {
+        return (contradiction ||= binary_operation_node_js_1.BinaryOperationNode.create(_one, _eq, value_node_js_1.ValueNode.createImmediate(0)));
+    }
+    return (tautology ||= binary_operation_node_js_1.BinaryOperationNode.create(_one, _eq, _one));
+}
+let char;
+let listNull;
+let listVal;
+/**
+ * When `in`, pushes a `null` value into the list resulting in `in (null)`. This
+ * is how TypeORM and Sequelize handle `in ()`. `in (null)` is logically the equivalent
+ * of `= null`, which returns `null`, which is a falsy expression in most SQL databases.
+ * We recommend NOT using this strategy if you plan to use `in` in `select`, `returning`,
+ * or `output` clauses, as the return type differs from the `SqlBool` default type.
+ *
+ * When `not in`, casts the left operand as `char` and pushes a literal value into
+ * the list resulting in `cast({{lhs}} as char) not in ({{VALUE}})`. Casting
+ * is required to avoid database errors with non-string columns.
+ *
+ * See {@link replaceWithNoncontingentExpression} for an alternative strategy.
+ */
+function pushValueIntoList(uniqueNotInLiteral) {
+    return function pushValueIntoList(node) {
+        if (node.operator.operator === 'in') {
+            return (0, object_utils_js_1.freeze)({
+                ...node,
+                rightOperand: (listNull ||= value_list_node_js_1.ValueListNode.create([
+                    value_node_js_1.ValueNode.createImmediate(null),
+                ])),
+            });
+        }
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            leftOperand: cast_node_js_1.CastNode.create(node.leftOperand, (char ||= data_type_node_js_1.DataTypeNode.create('char'))),
+            rightOperand: (listVal ||= value_list_node_js_1.ValueListNode.create([
+                value_node_js_1.ValueNode.createImmediate(uniqueNotInLiteral),
+            ])),
+        });
+    };
+}

package/dist/cjs/plugin/immediate-value/immediate-value-plugin.js

@@ -13,7 +13,7 @@ const immediate_value_transformer_js_1 = require("./immediate-value-transformer.
 class ImmediateValuePlugin {
     #transformer = new immediate_value_transformer_js_1.ImmediateValueTransformer();
     transformQuery(args) {
-        return this.#transformer.transformNode(args.node);
+        return this.#transformer.transformNode(args.node, args.queryId);
     }
     transformResult(args) {
         return Promise.resolve(args.result);

package/dist/cjs/plugin/immediate-value/immediate-value-transformer.d.ts

@@ -1,4 +1,5 @@
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
+import { PrimitiveValueListNode } from '../../operation-node/primitive-value-list-node.js';
 import { ValueNode } from '../../operation-node/value-node.js';
 /**
  * Transforms all ValueNodes to immediate.
@@ -9,5 +10,6 @@ import { ValueNode } from '../../operation-node/value-node.js';
  * @internal
  */
 export declare class ImmediateValueTransformer extends OperationNodeTransformer {
+    transformPrimitiveValueList(node: PrimitiveValueListNode): PrimitiveValueListNode;
     transformValue(node: ValueNode): ValueNode;
 }

package/dist/cjs/plugin/immediate-value/immediate-value-transformer.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImmediateValueTransformer = void 0;
 const operation_node_transformer_js_1 = require("../../operation-node/operation-node-transformer.js");
+const value_list_node_js_1 = require("../../operation-node/value-list-node.js");
+const value_node_js_1 = require("../../operation-node/value-node.js");
 /**
  * Transforms all ValueNodes to immediate.
  *
@@ -11,11 +13,11 @@ const operation_node_transformer_js_1 = require("../../operation-node/operation-
  * @internal
  */
 class ImmediateValueTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {
+    transformPrimitiveValueList(node) {
+        return value_list_node_js_1.ValueListNode.create(node.values.map(value_node_js_1.ValueNode.createImmediate));
+    }
     transformValue(node) {
-        return {
-            ...super.transformValue(node),
-            immediate: true,
-        };
+        return value_node_js_1.ValueNode.createImmediate(node.value);
     }
 }
 exports.ImmediateValueTransformer = ImmediateValueTransformer;

package/dist/cjs/plugin/with-schema/with-schema-plugin.js

@@ -8,7 +8,7 @@ class WithSchemaPlugin {
         this.#transformer = new with_schema_transformer_js_1.WithSchemaTransformer(schema);
     }
     transformQuery(args) {
-        return this.#transformer.transformNode(args.node);
+        return this.#transformer.transformNode(args.node, args.queryId);
     }
     async transformResult(args) {
         return args.result;

package/dist/cjs/plugin/with-schema/with-schema-transformer.d.ts

@@ -1,11 +1,16 @@
+import { AggregateFunctionNode } from '../../operation-node/aggregate-function-node.js';
+import { FunctionNode } from '../../operation-node/function-node.js';
 import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
 import { OperationNode } from '../../operation-node/operation-node.js';
 import { ReferencesNode } from '../../operation-node/references-node.js';
 import { SchemableIdentifierNode } from '../../operation-node/schemable-identifier-node.js';
+import { QueryId } from '../../util/query-id.js';
 export declare class WithSchemaTransformer extends OperationNodeTransformer {
     #private;
     constructor(schema: string);
-    protected transformNodeImpl<T extends OperationNode>(node: T): T;
-    protected transformSchemableIdentifier(node: SchemableIdentifierNode): SchemableIdentifierNode;
-    protected transformReferences(node: ReferencesNode): ReferencesNode;
+    protected transformNodeImpl<T extends OperationNode>(node: T, queryId: QueryId): T;
+    protected transformSchemableIdentifier(node: SchemableIdentifierNode, queryId: QueryId): SchemableIdentifierNode;
+    protected transformReferences(node: ReferencesNode, queryId: QueryId): ReferencesNode;
+    protected transformAggregateFunction(node: AggregateFunctionNode, queryId: QueryId): AggregateFunctionNode;
+    protected transformFunction(node: FunctionNode, queryId: QueryId): FunctionNode;
 }

package/dist/cjs/plugin/with-schema/with-schema-transformer.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WithSchemaTransformer = void 0;
 const alias_node_js_1 = require("../../operation-node/alias-node.js");
 const identifier_node_js_1 = require("../../operation-node/identifier-node.js");
+const list_node_js_1 = require("../../operation-node/list-node.js");
 const operation_node_transformer_js_1 = require("../../operation-node/operation-node-transformer.js");
 const schemable_identifier_node_js_1 = require("../../operation-node/schemable-identifier-node.js");
 const table_node_js_1 = require("../../operation-node/table-node.js");
@@ -19,6 +20,7 @@ const ROOT_OPERATION_NODES = (0, object_utils_js_1.freeze)({
     CreateTableNode: true,
     CreateTypeNode: true,
     CreateViewNode: true,
+    RefreshMaterializedViewNode: true,
     DeleteQueryNode: true,
     DropIndexNode: true,
     DropSchemaNode: true,
@@ -31,6 +33,10 @@ const ROOT_OPERATION_NODES = (0, object_utils_js_1.freeze)({
     UpdateQueryNode: true,
     MergeQueryNode: true,
 });
+const SCHEMALESS_FUNCTIONS = {
+    json_agg: true,
+    to_json: true,
+};
 class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNodeTransformer {
     #schema;
     #schemableIds = new Set();
@@ -39,9 +45,9 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
         super();
         this.#schema = schema;
     }
-    transformNodeImpl(node) {
+    transformNodeImpl(node, queryId) {
         if (!this.#isRootOperationNode(node)) {
-            return super.transformNodeImpl(node);
+            return super.transformNodeImpl(node, queryId);
         }
         const ctes = this.#collectCTEs(node);
         for (const cte of ctes) {
@@ -51,7 +57,7 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
         for (const table of tables) {
             this.#schemableIds.add(table);
         }
-        const transformed = super.transformNodeImpl(node);
+        const transformed = super.transformNodeImpl(node, queryId);
         for (const table of tables) {
             this.#schemableIds.delete(table);
         }
@@ -60,8 +66,8 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
         }
         return transformed;
     }
-    transformSchemableIdentifier(node) {
-        const transformed = super.transformSchemableIdentifier(node);
+    transformSchemableIdentifier(node, queryId) {
+        const transformed = super.transformSchemableIdentifier(node, queryId);
         if (transformed.schema || !this.#schemableIds.has(node.identifier.name)) {
             return transformed;
         }
@@ -70,8 +76,8 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
             schema: identifier_node_js_1.IdentifierNode.create(this.#schema),
         };
     }
-    transformReferences(node) {
-        const transformed = super.transformReferences(node);
+    transformReferences(node, queryId) {
+        const transformed = super.transformReferences(node, queryId);
         if (transformed.table.table.schema) {
             return transformed;
         }
@@ -80,6 +86,28 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
             table: table_node_js_1.TableNode.createWithSchema(this.#schema, transformed.table.table.identifier.name),
         };
     }
+    transformAggregateFunction(node, queryId) {
+        return {
+            ...super.transformAggregateFunction({ ...node, aggregated: [] }, queryId),
+            aggregated: this.#transformTableArgsWithoutSchemas(node, queryId, 'aggregated'),
+        };
+    }
+    transformFunction(node, queryId) {
+        return {
+            ...super.transformFunction({ ...node, arguments: [] }, queryId),
+            arguments: this.#transformTableArgsWithoutSchemas(node, queryId, 'arguments'),
+        };
+    }
+    #transformTableArgsWithoutSchemas(node, queryId, argsKey) {
+        return SCHEMALESS_FUNCTIONS[node.func]
+            ? node[argsKey].map((arg) => !table_node_js_1.TableNode.is(arg) || arg.table.schema
+                ? this.transformNode(arg, queryId)
+                : {
+                    ...arg,
+                    table: this.transformIdentifier(arg.table.identifier, queryId),
+                })
+            : this.transformNodeList(node[argsKey], queryId);
+    }
     #isRootOperationNode(node) {
         return node.kind in ROOT_OPERATION_NODES;
     }
@@ -117,13 +145,16 @@ class WithSchemaTransformer extends operation_node_transformer_js_1.OperationNod
         return ctes;
     }
     #collectSchemableIdsFromTableExpr(node, schemableIds) {
-        const table = table_node_js_1.TableNode.is(node)
-            ? node
-            : alias_node_js_1.AliasNode.is(node) && table_node_js_1.TableNode.is(node.node)
-                ? node.node
-                : null;
-        if (table) {
-            this.#collectSchemableId(table.table, schemableIds);
+        if (table_node_js_1.TableNode.is(node)) {
+            this.#collectSchemableId(node.table, schemableIds);
+        }
+        else if (alias_node_js_1.AliasNode.is(node) && table_node_js_1.TableNode.is(node.node)) {
+            this.#collectSchemableId(node.node.table, schemableIds);
+        }
+        else if (list_node_js_1.ListNode.is(node)) {
+            for (const table of node.items) {
+                this.#collectSchemableIdsFromTableExpr(table, schemableIds);
+            }
         }
     }
     #collectSchemableId(node, schemableIds) {

package/dist/cjs/query-builder/aggregate-function-builder.d.ts

@@ -2,13 +2,13 @@ import { AggregateFunctionNode } from '../operation-node/aggregate-function-node
 import { AliasNode } from '../operation-node/alias-node.js';
 import { OverBuilder } from './over-builder.js';
 import { AliasableExpression, AliasedExpression, Expression } from '../expression/expression.js';
-import { ReferenceExpression, StringReference } from '../parser/reference-parser.js';
+import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { SqlBool } from '../util/type-utils.js';
 import { ExpressionOrFactory } from '../parser/expression-parser.js';
-import { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
-import { OrderByDirectionExpression } from '../parser/order-by-parser.js';
-export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements AliasableExpression<O> {
+import { DirectedOrderByStringReference, OrderByExpression, OrderByModifiers } from '../parser/order-by-parser.js';
+import { OrderByInterface } from './order-by-interface.js';
+export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unknown> implements OrderByInterface<DB, TB, {}>, AliasableExpression<O> {
     #private;
     constructor(props: AggregateFunctionBuilderProps);
     /** @private */
@@ -108,7 +108,85 @@ export declare class AggregateFunctionBuilder<DB, TB extends keyof DB, O = unkno
      * inner join "pet" ON "pet"."owner_id" = "person"."id"
      * ```
      */
-    orderBy<OE extends StringReference<DB, TB> | DynamicReferenceBuilder<any>>(orderBy: OE, direction?: OrderByDirectionExpression): AggregateFunctionBuilder<DB, TB, O>;
+    orderBy<OE extends OrderByExpression<DB, TB, {}>>(expr: OE, modifiers?: OrderByModifiers): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated It does ~2-2.6x more compile-time instantiations compared to multiple chained `orderBy(expr, modifiers?)` calls (in `order by` clauses with reasonable item counts), and has broken autocompletion.
+     */
+    orderBy<OE extends OrderByExpression<DB, TB, {}> | DirectedOrderByStringReference<DB, TB, {}>>(exprs: ReadonlyArray<OE>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated It does ~2.9x more compile-time instantiations compared to a `orderBy(expr, direction)` call.
+     */
+    orderBy<OE extends DirectedOrderByStringReference<DB, TB, {}>>(expr: OE): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated Use `orderBy(expr, (ob) => ...)` instead.
+     */
+    orderBy<OE extends OrderByExpression<DB, TB, {}>>(expr: OE, modifiers: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Clears the `order by` clause from the query.
+     *
+     * See {@link orderBy} for adding an `order by` clause or item to a query.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const query = db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   .orderBy('id', 'desc')
+     *
+     * const results = await query
+     *   .clearOrderBy()
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     */
+    clearOrderBy(): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * Adds a `withing group` clause with a nested `order by` clause after the function.
+     *
+     * This is only supported by some dialects like PostgreSQL or MS SQL Server.
+     *
+     * ### Examples
+     *
+     * Most frequent person name:
+     *
+     * ```ts
+     * const result = await db
+     *   .selectFrom('person')
+     *   .select((eb) => [
+     *     eb.fn
+     *       .agg<string>('mode')
+     *       .withinGroupOrderBy('person.first_name')
+     *       .as('most_frequent_name')
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select mode() within group (order by "person"."first_name") as "most_frequent_name"
+     * from "person"
+     * ```
+     */
+    withinGroupOrderBy<OE extends OrderByExpression<DB, TB, {}>>(expr: OE, modifiers?: OrderByModifiers): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated It does ~2-2.6x more compile-time instantiations compared to multiple chained `withinGroupOrderBy(expr, modifiers?)` calls (in `order by` clauses with reasonable item counts), and has broken autocompletion.
+     */
+    withinGroupOrderBy<OE extends OrderByExpression<DB, TB, {}> | DirectedOrderByStringReference<DB, TB, {}>>(exprs: ReadonlyArray<OE>): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated It does ~2.9x more compile-time instantiations compared to a `withinGroupOrderBy(expr, direction)` call.
+     */
+    withinGroupOrderBy<OE extends DirectedOrderByStringReference<DB, TB, {}>>(expr: OE): AggregateFunctionBuilder<DB, TB, O>;
+    /**
+     * @deprecated Use `withinGroupOrderBy(expr, (ob) => ...)` instead.
+     */
+    withinGroupOrderBy<OE extends OrderByExpression<DB, TB, {}>>(expr: OE, modifiers: Expression<any>): AggregateFunctionBuilder<DB, TB, O>;
     /**
      * Adds a `filter` clause with a nested `where` clause after the function.
      *

package/dist/cjs/query-builder/aggregate-function-builder.js

@@ -5,10 +5,10 @@ const object_utils_js_1 = require("../util/object-utils.js");
 const aggregate_function_node_js_1 = require("../operation-node/aggregate-function-node.js");
 const alias_node_js_1 = require("../operation-node/alias-node.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
-const prevent_await_js_1 = require("../util/prevent-await.js");
 const parse_utils_js_1 = require("../parser/parse-utils.js");
 const binary_operation_parser_js_1 = require("../parser/binary-operation-parser.js");
 const order_by_parser_js_1 = require("../parser/order-by-parser.js");
+const query_node_js_1 = require("../operation-node/query-node.js");
 class AggregateFunctionBuilder {
     #props;
     constructor(props) {
@@ -73,33 +73,22 @@ class AggregateFunctionBuilder {
             aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithDistinct(this.#props.aggregateFunctionNode),
         });
     }
-    /**
-     * Adds an `order by` clause inside the aggregate function.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const result = await db
-     *   .selectFrom('person')
-     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
-     *   .select((eb) =>
-     *     eb.fn.jsonAgg('pet').orderBy('pet.name').as('person_pets')
-     *   )
-     *   .executeTakeFirstOrThrow()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select json_agg("pet" order by "pet"."name") as "person_pets"
-     * from "person"
-     * inner join "pet" ON "pet"."owner_id" = "person"."id"
-     * ```
-     */
-    orderBy(orderBy, direction) {
+    orderBy(...args) {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: query_node_js_1.QueryNode.cloneWithOrderByItems(this.#props.aggregateFunctionNode, (0, order_by_parser_js_1.parseOrderBy)(args)),
+        });
+    }
+    clearOrderBy() {
+        return new AggregateFunctionBuilder({
+            ...this.#props,
+            aggregateFunctionNode: query_node_js_1.QueryNode.cloneWithoutOrderBy(this.#props.aggregateFunctionNode),
+        });
+    }
+    withinGroupOrderBy(...args) {
         return new AggregateFunctionBuilder({
             ...this.#props,
-            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithOrderBy(this.#props.aggregateFunctionNode, (0, order_by_parser_js_1.parseOrderBy)([orderBy, direction])),
+            aggregateFunctionNode: aggregate_function_node_js_1.AggregateFunctionNode.cloneWithOrderBy(this.#props.aggregateFunctionNode, (0, order_by_parser_js_1.parseOrderBy)(args), true),
         });
     }
     filterWhere(...args) {
@@ -228,7 +217,6 @@ class AggregateFunctionBuilder {
     }
 }
 exports.AggregateFunctionBuilder = AggregateFunctionBuilder;
-(0, prevent_await_js_1.preventAwait)(AggregateFunctionBuilder, "don't await AggregateFunctionBuilder instances. They are never executed directly and are always just a part of a query.");
 /**
  * {@link AggregateFunctionBuilder} with an alias. The result of calling {@link AggregateFunctionBuilder.as}.
  */

package/dist/cjs/query-builder/cte-builder.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CTEBuilder = void 0;
 const common_table_expression_node_js_1 = require("../operation-node/common-table-expression-node.js");
-const prevent_await_js_1 = require("../util/prevent-await.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 class CTEBuilder {
     #props;
@@ -36,4 +35,3 @@ class CTEBuilder {
     }
 }
 exports.CTEBuilder = CTEBuilder;
-(0, prevent_await_js_1.preventAwait)(CTEBuilder, "don't await CTEBuilder instances. They are never executed directly and are always just a part of a query.");