kysely 0.9.1 → 0.9.2

package/dist/cjs/dialect/mysql/mysql-driver.js

@@ -107,13 +107,13 @@ class MysqlConnection {
     async executeQuery(compiledQuery) {
         const result = await this.#executeQuery(compiledQuery);
         if ((0, object_utils_js_1.isObject)(result) && 'insertId' in result && 'affectedRows' in result) {
-            if (result.insertId) {
+            if ((0, object_utils_js_1.isNumber)(result.insertId) && result.insertId > 0) {
                 return {
                     insertedPrimaryKey: result.insertId,
                     rows: [],
                 };
             }
-            else {
+            else if ((0, object_utils_js_1.isNumber)(result.affectedRows)) {
                 return {
                     numUpdatedOrDeletedRows: result.affectedRows,
                     rows: [],

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

@@ -21,5 +21,6 @@ export declare const JoinNode: Readonly<{
     is(node: OperationNode): node is JoinNode;
     create(joinType: JoinType, table: JoinTableNode): JoinNode;
     createWithOn(joinType: JoinType, table: JoinTableNode, on: JoinNodeOnNode): JoinNode;
-    cloneWithOn(joinNode: JoinNode, op: 'And' | 'Or', on: JoinNodeOnNode): JoinNode;
+    cloneWithOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
+    cloneWithOrOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
 }>;

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

@@ -27,14 +27,16 @@ exports.JoinNode = (0, object_utils_js_1.freeze)({
             on,
         });
     },
-    cloneWithOn(joinNode, op, on) {
+    cloneWithOn(joinNode, on) {
         return (0, object_utils_js_1.freeze)({
             ...joinNode,
-            on: joinNode.on
-                ? op === 'And'
-                    ? and_node_js_1.AndNode.create(joinNode.on, on)
-                    : or_node_js_1.OrNode.create(joinNode.on, on)
-                : on,
+            on: joinNode.on ? and_node_js_1.AndNode.create(joinNode.on, on) : on,
+        });
+    },
+    cloneWithOrOn(joinNode, on) {
+        return (0, object_utils_js_1.freeze)({
+            ...joinNode,
+            on: joinNode.on ? or_node_js_1.OrNode.create(joinNode.on, on) : on,
         });
     },
 });

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

@@ -16,7 +16,8 @@ export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
     isMutating(node: OperationNode): node is MutatingQueryNode;
     isFilterable(node: OperationNode): node is FilterableQueryNode;
-    cloneWithWhere<T extends FilterableQueryNode>(node: T, op: 'And' | 'Or', filter: WhereChildNode): T;
-    cloneWithJoin<T_1 extends FilterableQueryNode>(node: T_1, join: JoinNode): T_1;
-    cloneWithReturning<T_2 extends MutatingQueryNode>(node: T_2, selections: ReadonlyArray<SelectionNode>): T_2;
+    cloneWithWhere<T extends FilterableQueryNode>(node: T, filter: WhereChildNode): T;
+    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, filter: WhereChildNode): T_1;
+    cloneWithJoin<T_2 extends FilterableQueryNode>(node: T_2, join: JoinNode): T_2;
+    cloneWithReturning<T_3 extends MutatingQueryNode>(node: T_3, selections: ReadonlyArray<SelectionNode>): T_3;
 }>;

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

@@ -28,11 +28,19 @@ exports.QueryNode = (0, object_utils_js_1.freeze)({
             delete_query_node_js_1.DeleteQueryNode.is(node) ||
             update_query_node_js_1.UpdateQueryNode.is(node));
     },
-    cloneWithWhere(node, op, filter) {
+    cloneWithWhere(node, filter) {
         return (0, object_utils_js_1.freeze)({
             ...node,
             where: node.where
-                ? where_node_js_1.WhereNode.cloneWithFilter(node.where, op, filter)
+                ? where_node_js_1.WhereNode.cloneWithFilter(node.where, 'And', filter)
+                : where_node_js_1.WhereNode.create(filter),
+        });
+    },
+    cloneWithOrWhere(node, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            where: node.where
+                ? where_node_js_1.WhereNode.cloneWithFilter(node.where, 'Or', filter)
                 : where_node_js_1.WhereNode.create(filter),
         });
     },

package/dist/cjs/operation-node/select-query-node.d.ts

@@ -42,6 +42,7 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
-    cloneWithHaving(selectNode: SelectQueryNode, op: 'And' | 'Or', filter: HavingNodeChild): SelectQueryNode;
+    cloneWithHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
+    cloneWithOrHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
     cloneWithDistinct(selectNode: SelectQueryNode): SelectQueryNode;
 }>;

package/dist/cjs/operation-node/select-query-node.js

@@ -72,11 +72,19 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
             offset,
         });
     },
-    cloneWithHaving(selectNode, op, filter) {
+    cloneWithHaving(selectNode, filter) {
         return (0, object_utils_js_1.freeze)({
             ...selectNode,
             having: selectNode.having
-                ? having_node_js_1.HavingNode.cloneWithFilter(selectNode.having, op, filter)
+                ? having_node_js_1.HavingNode.cloneWithFilter(selectNode.having, 'And', filter)
+                : having_node_js_1.HavingNode.create(filter),
+        });
+    },
+    cloneWithOrHaving(selectNode, filter) {
+        return (0, object_utils_js_1.freeze)({
+            ...selectNode,
+            having: selectNode.having
+                ? having_node_js_1.HavingNode.cloneWithFilter(selectNode.having, 'Or', filter)
                 : having_node_js_1.HavingNode.create(filter),
         });
     },

package/dist/cjs/parser/group-by-parser.d.ts

@@ -0,0 +1,4 @@
+import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
+import { ParseContext } from './parse-context.js';
+import { ReferenceExpressionOrList } from './reference-parser.js';
+export declare function parseGroupBy(ctx: ParseContext, orderBy: ReferenceExpressionOrList<any, any>): GroupByItemNode[];

package/dist/cjs/parser/group-by-parser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGroupBy = void 0;
+const group_by_item_node_js_1 = require("../operation-node/group-by-item-node.js");
+const reference_parser_js_1 = require("./reference-parser.js");
+function parseGroupBy(ctx, orderBy) {
+    return (0, reference_parser_js_1.parseReferenceExpressionOrList)(ctx, orderBy).map(group_by_item_node_js_1.GroupByItemNode.create);
+}
+exports.parseGroupBy = parseGroupBy;

package/dist/cjs/parser/order-by-parser.d.ts

@@ -1,10 +1,8 @@
-import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
-import { RawNode } from '../operation-node/raw-node.js';
+import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.js';
 import { ReferenceExpression } from './reference-parser.js';
 export declare type OrderByDirection = 'asc' | 'desc';
 export declare type OrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | keyof O;
 export declare type OrderByDirectionExpression = OrderByDirection | AnyRawBuilder;
-export declare function parseOrderByExpression(ctx: ParseContext, expr: OrderByExpression<any, any, any>): ReferenceExpressionNode;
-export declare function parseOrderByDirectionExpression(expr?: OrderByDirectionExpression): RawNode | undefined;
+export declare function parseOrderBy(ctx: ParseContext, orderBy: OrderByExpression<any, any, any>, direction?: OrderByDirectionExpression): OrderByItemNode;

package/dist/cjs/parser/order-by-parser.js

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseOrderByDirectionExpression = exports.parseOrderByExpression = void 0;
+exports.parseOrderBy = void 0;
+const order_by_item_node_js_1 = require("../operation-node/order-by-item-node.js");
 const raw_node_js_1 = require("../operation-node/raw-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
+function parseOrderBy(ctx, orderBy, direction) {
+    return order_by_item_node_js_1.OrderByItemNode.create(parseOrderByExpression(ctx, orderBy), parseOrderByDirectionExpression(direction));
+}
+exports.parseOrderBy = parseOrderBy;
 function parseOrderByExpression(ctx, expr) {
     return (0, reference_parser_js_1.parseReferenceExpression)(ctx, expr);
 }
-exports.parseOrderByExpression = parseOrderByExpression;
 function parseOrderByDirectionExpression(expr) {
     if (!expr) {
         return undefined;
@@ -18,4 +22,3 @@ function parseOrderByDirectionExpression(expr) {
         return expr.toOperationNode();
     }
 }
-exports.parseOrderByDirectionExpression = parseOrderByDirectionExpression;

package/dist/cjs/parser/reference-parser.d.ts

@@ -9,7 +9,7 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { QueryBuilder } from '../query-builder/query-builder.js';
 import { ParseContext } from './parse-context.js';
 export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
-export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReferenceExpression<DB, TB>[];
+export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
 export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends QueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => QueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
 declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, S extends string, R = RowType<DB, TB>> = S extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : S extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : S extends keyof R ? R[S] : PrimitiveValue;

package/dist/cjs/parser/reference-parser.js

@@ -9,7 +9,7 @@ const table_node_js_1 = require("../operation-node/table-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const query_node_js_1 = require("../operation-node/query-node.js");
 function parseReferenceExpressionOrList(ctx, arg) {
-    if (Array.isArray(arg)) {
+    if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
         return arg.map((it) => parseReferenceExpression(ctx, it));
     }
     else {

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

@@ -13,13 +13,13 @@ class JoinBuilder {
     on(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'And', (0, filter_parser_js_1.parseOnFilter)(this.#props.parseContext, args)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, filter_parser_js_1.parseOnFilter)(this.#props.parseContext, args)),
         });
     }
     orOn(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'Or', (0, filter_parser_js_1.parseOnFilter)(this.#props.parseContext, args)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOrOn(this.#props.joinNode, (0, filter_parser_js_1.parseOnFilter)(this.#props.parseContext, args)),
         });
     }
     /**
@@ -31,7 +31,7 @@ class JoinBuilder {
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'And', (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -43,7 +43,7 @@ class JoinBuilder {
     orOnRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'Or', (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOrOn(this.#props.joinNode, (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -55,7 +55,7 @@ class JoinBuilder {
     onExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'And', (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -67,7 +67,7 @@ class JoinBuilder {
     onNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'And', (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -79,7 +79,7 @@ class JoinBuilder {
     orOnExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'Or', (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOrOn(this.#props.joinNode, (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -91,7 +91,7 @@ class JoinBuilder {
     orOnNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, 'Or', (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
+            joinNode: join_node_js_1.JoinNode.cloneWithOrOn(this.#props.joinNode, (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
         });
     }
     toOperationNode() {

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

@@ -6,13 +6,10 @@ const join_parser_js_1 = require("../parser/join-parser.js");
 const select_parser_js_1 = require("../parser/select-parser.js");
 const filter_parser_js_1 = require("../parser/filter-parser.js");
 const insert_values_parser_js_1 = require("../parser/insert-values-parser.js");
-const reference_parser_js_1 = require("../parser/reference-parser.js");
-const order_by_item_node_js_1 = require("../operation-node/order-by-item-node.js");
 const select_query_node_js_1 = require("../operation-node/select-query-node.js");
 const insert_query_node_js_1 = require("../operation-node/insert-query-node.js");
 const query_node_js_1 = require("../operation-node/query-node.js");
 const order_by_parser_js_1 = require("../parser/order-by-parser.js");
-const group_by_item_node_js_1 = require("../operation-node/group-by-item-node.js");
 const update_query_node_js_1 = require("../operation-node/update-query-node.js");
 const update_set_parser_js_1 = require("../parser/update-set-parser.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
@@ -22,6 +19,7 @@ const on_conflict_parser_js_1 = require("../parser/on-conflict-parser.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const delete_query_node_js_1 = require("../operation-node/delete-query-node.js");
 const on_duplicate_key_node_js_1 = require("../operation-node/on-duplicate-key-node.js");
+const group_by_parser_js_1 = require("../parser/group-by-parser.js");
 /**
  * The main query builder class.
  *
@@ -46,7 +44,7 @@ class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseWhereFilter)(this.#props.parseContext, args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseWhereFilter)(this.#props.parseContext, args)),
         });
     }
     /**
@@ -104,14 +102,14 @@ class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     orWhere(...args) {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseWhereFilter)(this.#props.parseContext, args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseWhereFilter)(this.#props.parseContext, args)),
         });
     }
     /**
@@ -124,7 +122,7 @@ class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -190,7 +188,7 @@ class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -200,7 +198,7 @@ class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -210,7 +208,7 @@ class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -220,14 +218,14 @@ class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
+            queryNode: query_node_js_1.QueryNode.cloneWithOrWhere(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
         });
     }
     having(...args) {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseHavingFilter)(this.#props.parseContext, args)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, (0, filter_parser_js_1.parseHavingFilter)(this.#props.parseContext, args)),
         });
     }
     /**
@@ -238,14 +236,14 @@ class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     orHaving(...args) {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseHavingFilter)(this.#props.parseContext, args)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, (0, filter_parser_js_1.parseHavingFilter)(this.#props.parseContext, args)),
         });
     }
     /**
@@ -256,7 +254,7 @@ class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, (0, filter_parser_js_1.parseReferenceFilter)(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -267,7 +265,7 @@ class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -278,7 +276,7 @@ class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -289,7 +287,7 @@ class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, (0, filter_parser_js_1.parseExistFilter)(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -300,7 +298,7 @@ class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, (0, filter_parser_js_1.parseNotExistFilter)(this.#props.parseContext, arg)),
         });
     }
     select(selection) {
@@ -717,14 +715,14 @@ class QueryBuilder {
         assertCanHaveOrderByClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, order_by_item_node_js_1.OrderByItemNode.create((0, order_by_parser_js_1.parseOrderByExpression)(this.#props.parseContext, orderBy), (0, order_by_parser_js_1.parseOrderByDirectionExpression)(direction))),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, (0, order_by_parser_js_1.parseOrderBy)(this.#props.parseContext, orderBy, direction)),
         });
     }
     groupBy(orderBy) {
         assertCanHaveGroupByClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, (0, reference_parser_js_1.parseReferenceExpressionOrList)(this.#props.parseContext, orderBy).map(group_by_item_node_js_1.GroupByItemNode.create)),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, (0, group_by_parser_js_1.parseGroupBy)(this.#props.parseContext, orderBy)),
         });
     }
     /**
@@ -964,7 +962,7 @@ function assertCanHaveUpdates(node) {
 }
 function assertCanHaveReturningClause(node) {
     if (!query_node_js_1.QueryNode.isMutating(node)) {
-        throw new Error('only an insert, delete and update queries can have a returning clause');
+        throw new Error('only insert, delete and update queries can have a returning clause');
     }
 }
 function assertCanHaveOrderByClause(node) {

package/dist/cjs/query-compiler/compiled-query.d.ts

@@ -1,4 +1,4 @@
 export interface CompiledQuery {
     readonly sql: string;
-    readonly parameters: ReadonlyArray<any>;
+    readonly parameters: ReadonlyArray<unknown>;
 }

package/dist/cjs/query-compiler/default-query-compiler.d.ts

@@ -126,10 +126,10 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitAddConstraint(node: AddConstraintNode): void;
     protected visitDropConstraint(node: DropConstraintNode): void;
     protected append(str: string): void;
-    protected appendValue(value: PrimitiveValue): void;
+    protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;
     protected getCurrentParameterPlaceholder(): string;
-    protected addParameter(parameter: any): void;
+    protected addParameter(parameter: unknown): void;
     protected appendImmediateValue(value: PrimitiveValue): void;
 }

package/dist/cjs/query-compiler/default-query-compiler.js

@@ -633,8 +633,8 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
     append(str) {
         this.#sql += str;
     }
-    appendValue(value) {
-        this.addParameter(value);
+    appendValue(parameter) {
+        this.addParameter(parameter);
         this.append(this.getCurrentParameterPlaceholder());
     }
     getLeftIdentifierWrapper() {

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

@@ -1,16 +1,16 @@
 /// <reference types="node" />
 export declare type PrimitiveValue = string | number | boolean | null | Date | Buffer | BigInt;
-export declare function isEmpty(obj: ArrayLike<any> | string | object | Buffer): boolean;
-export declare function isString(obj: any): obj is string;
-export declare function isNumber(obj: any): obj is number;
-export declare function isBoolean(obj: any): obj is boolean;
-export declare function isNull(obj: any): obj is null;
-export declare function isDate(obj: any): obj is Date;
-export declare function isBuffer(obj: any): obj is Buffer;
-export declare function isBigInt(obj: any): obj is BigInt;
-export declare function isPrimitive(obj: any): obj is PrimitiveValue;
-export declare function isFunction(obj: any): obj is Function;
-export declare function isObject(obj: any): obj is Record<string, any>;
+export declare function isEmpty(obj: ArrayLike<unknown> | string | object | Buffer): boolean;
+export declare function isString(obj: unknown): obj is string;
+export declare function isNumber(obj: unknown): obj is number;
+export declare function isBoolean(obj: unknown): obj is boolean;
+export declare function isNull(obj: unknown): obj is null;
+export declare function isDate(obj: unknown): obj is Date;
+export declare function isBuffer(obj: unknown): obj is Buffer;
+export declare function isBigInt(obj: unknown): obj is BigInt;
+export declare function isPrimitive(obj: unknown): obj is PrimitiveValue;
+export declare function isFunction(obj: unknown): obj is Function;
+export declare function isObject(obj: unknown): obj is Record<string, unknown>;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
 export declare function freeze<T>(obj: T): Readonly<T>;
 export declare function asArray<T>(arg: T | T[]): T[];

package/dist/cjs/util/object-utils.js

@@ -54,7 +54,7 @@ function isFunction(obj) {
 }
 exports.isFunction = isFunction;
 function isObject(obj) {
-    return obj && typeof obj === 'object';
+    return typeof obj === 'object' && obj !== null;
 }
 exports.isObject = isObject;
 function getLast(arr) {

package/dist/esm/dialect/mysql/mysql-driver.js

@@ -1,4 +1,4 @@
-import { isFunction, isObject } from '../../util/object-utils.js';
+import { isFunction, isNumber, isObject, } from '../../util/object-utils.js';
 const PRIVATE_RELEASE_METHOD = Symbol();
 export class MysqlDriver {
     #config;
@@ -103,13 +103,13 @@ class MysqlConnection {
     async executeQuery(compiledQuery) {
         const result = await this.#executeQuery(compiledQuery);
         if (isObject(result) && 'insertId' in result && 'affectedRows' in result) {
-            if (result.insertId) {
+            if (isNumber(result.insertId) && result.insertId > 0) {
                 return {
                     insertedPrimaryKey: result.insertId,
                     rows: [],
                 };
             }
-            else {
+            else if (isNumber(result.affectedRows)) {
                 return {
                     numUpdatedOrDeletedRows: result.affectedRows,
                     rows: [],

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

@@ -21,5 +21,6 @@ export declare const JoinNode: Readonly<{
     is(node: OperationNode): node is JoinNode;
     create(joinType: JoinType, table: JoinTableNode): JoinNode;
     createWithOn(joinType: JoinType, table: JoinTableNode, on: JoinNodeOnNode): JoinNode;
-    cloneWithOn(joinNode: JoinNode, op: 'And' | 'Or', on: JoinNodeOnNode): JoinNode;
+    cloneWithOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
+    cloneWithOrOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
 }>;

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

@@ -24,14 +24,16 @@ export const JoinNode = freeze({
             on,
         });
     },
-    cloneWithOn(joinNode, op, on) {
+    cloneWithOn(joinNode, on) {
         return freeze({
             ...joinNode,
-            on: joinNode.on
-                ? op === 'And'
-                    ? AndNode.create(joinNode.on, on)
-                    : OrNode.create(joinNode.on, on)
-                : on,
+            on: joinNode.on ? AndNode.create(joinNode.on, on) : on,
+        });
+    },
+    cloneWithOrOn(joinNode, on) {
+        return freeze({
+            ...joinNode,
+            on: joinNode.on ? OrNode.create(joinNode.on, on) : on,
         });
     },
 });

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

@@ -16,7 +16,8 @@ export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
     isMutating(node: OperationNode): node is MutatingQueryNode;
     isFilterable(node: OperationNode): node is FilterableQueryNode;
-    cloneWithWhere<T extends FilterableQueryNode>(node: T, op: 'And' | 'Or', filter: WhereChildNode): T;
-    cloneWithJoin<T_1 extends FilterableQueryNode>(node: T_1, join: JoinNode): T_1;
-    cloneWithReturning<T_2 extends MutatingQueryNode>(node: T_2, selections: ReadonlyArray<SelectionNode>): T_2;
+    cloneWithWhere<T extends FilterableQueryNode>(node: T, filter: WhereChildNode): T;
+    cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, filter: WhereChildNode): T_1;
+    cloneWithJoin<T_2 extends FilterableQueryNode>(node: T_2, join: JoinNode): T_2;
+    cloneWithReturning<T_3 extends MutatingQueryNode>(node: T_3, selections: ReadonlyArray<SelectionNode>): T_3;
 }>;

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

@@ -25,11 +25,19 @@ export const QueryNode = freeze({
             DeleteQueryNode.is(node) ||
             UpdateQueryNode.is(node));
     },
-    cloneWithWhere(node, op, filter) {
+    cloneWithWhere(node, filter) {
         return freeze({
             ...node,
             where: node.where
-                ? WhereNode.cloneWithFilter(node.where, op, filter)
+                ? WhereNode.cloneWithFilter(node.where, 'And', filter)
+                : WhereNode.create(filter),
+        });
+    },
+    cloneWithOrWhere(node, filter) {
+        return freeze({
+            ...node,
+            where: node.where
+                ? WhereNode.cloneWithFilter(node.where, 'Or', filter)
                 : WhereNode.create(filter),
         });
     },

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

@@ -42,6 +42,7 @@ export declare const SelectQueryNode: Readonly<{
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
-    cloneWithHaving(selectNode: SelectQueryNode, op: 'And' | 'Or', filter: HavingNodeChild): SelectQueryNode;
+    cloneWithHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
+    cloneWithOrHaving(selectNode: SelectQueryNode, filter: HavingNodeChild): SelectQueryNode;
     cloneWithDistinct(selectNode: SelectQueryNode): SelectQueryNode;
 }>;

package/dist/esm/operation-node/select-query-node.js

@@ -69,11 +69,19 @@ export const SelectQueryNode = freeze({
             offset,
         });
     },
-    cloneWithHaving(selectNode, op, filter) {
+    cloneWithHaving(selectNode, filter) {
         return freeze({
             ...selectNode,
             having: selectNode.having
-                ? HavingNode.cloneWithFilter(selectNode.having, op, filter)
+                ? HavingNode.cloneWithFilter(selectNode.having, 'And', filter)
+                : HavingNode.create(filter),
+        });
+    },
+    cloneWithOrHaving(selectNode, filter) {
+        return freeze({
+            ...selectNode,
+            having: selectNode.having
+                ? HavingNode.cloneWithFilter(selectNode.having, 'Or', filter)
                 : HavingNode.create(filter),
         });
     },

package/dist/esm/parser/group-by-parser.d.ts

@@ -0,0 +1,4 @@
+import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
+import { ParseContext } from './parse-context.js';
+import { ReferenceExpressionOrList } from './reference-parser.js';
+export declare function parseGroupBy(ctx: ParseContext, orderBy: ReferenceExpressionOrList<any, any>): GroupByItemNode[];

package/dist/esm/parser/group-by-parser.js

@@ -0,0 +1,5 @@
+import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
+import { parseReferenceExpressionOrList, } from './reference-parser.js';
+export function parseGroupBy(ctx, orderBy) {
+    return parseReferenceExpressionOrList(ctx, orderBy).map(GroupByItemNode.create);
+}

package/dist/esm/parser/order-by-parser.d.ts

@@ -1,10 +1,8 @@
-import { ReferenceExpressionNode } from '../operation-node/operation-node-utils.js';
-import { RawNode } from '../operation-node/raw-node.js';
+import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.js';
 import { ReferenceExpression } from './reference-parser.js';
 export declare type OrderByDirection = 'asc' | 'desc';
 export declare type OrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | keyof O;
 export declare type OrderByDirectionExpression = OrderByDirection | AnyRawBuilder;
-export declare function parseOrderByExpression(ctx: ParseContext, expr: OrderByExpression<any, any, any>): ReferenceExpressionNode;
-export declare function parseOrderByDirectionExpression(expr?: OrderByDirectionExpression): RawNode | undefined;
+export declare function parseOrderBy(ctx: ParseContext, orderBy: OrderByExpression<any, any, any>, direction?: OrderByDirectionExpression): OrderByItemNode;

package/dist/esm/parser/order-by-parser.js

@@ -1,9 +1,13 @@
+import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
 import { parseReferenceExpression, } from './reference-parser.js';
-export function parseOrderByExpression(ctx, expr) {
+export function parseOrderBy(ctx, orderBy, direction) {
+    return OrderByItemNode.create(parseOrderByExpression(ctx, orderBy), parseOrderByDirectionExpression(direction));
+}
+function parseOrderByExpression(ctx, expr) {
     return parseReferenceExpression(ctx, expr);
 }
-export function parseOrderByDirectionExpression(expr) {
+function parseOrderByDirectionExpression(expr) {
     if (!expr) {
         return undefined;
     }

package/dist/esm/parser/reference-parser.d.ts

@@ -9,7 +9,7 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
 import { QueryBuilder } from '../query-builder/query-builder.js';
 import { ParseContext } from './parse-context.js';
 export declare type ReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB> | DynamicReferenceBuilder<any>;
-export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReferenceExpression<DB, TB>[];
+export declare type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
 export declare type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
 export declare type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends RawBuilder<infer O> ? O : RE extends (qb: any) => RawBuilder<infer O> ? O : RE extends QueryBuilder<any, any, infer O> ? ValueType<O> : RE extends (qb: any) => QueryBuilder<any, any, infer O> ? ValueType<O> : PrimitiveValue;
 declare type ExtractTypeFromStringReference<DB, TB extends keyof DB, S extends string, R = RowType<DB, TB>> = S extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : S extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : S extends keyof R ? R[S] : PrimitiveValue;

package/dist/esm/parser/reference-parser.js

@@ -3,10 +3,10 @@ import { ColumnNode } from '../operation-node/column-node.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ReferenceNode } from '../operation-node/reference-node.js';
 import { TableNode } from '../operation-node/table-node.js';
-import { isFunction, isString } from '../util/object-utils.js';
+import { isFunction, isReadonlyArray, isString, } from '../util/object-utils.js';
 import { QueryNode } from '../operation-node/query-node.js';
 export function parseReferenceExpressionOrList(ctx, arg) {
-    if (Array.isArray(arg)) {
+    if (isReadonlyArray(arg)) {
         return arg.map((it) => parseReferenceExpression(ctx, it));
     }
     else {

package/dist/esm/query-builder/join-builder.js

@@ -10,13 +10,13 @@ export class JoinBuilder {
     on(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseOnFilter(this.#props.parseContext, args)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseOnFilter(this.#props.parseContext, args)),
         });
     }
     orOn(...args) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseOnFilter(this.#props.parseContext, args)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseOnFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -28,7 +28,7 @@ export class JoinBuilder {
     onRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -40,7 +40,7 @@ export class JoinBuilder {
     orOnRef(lhs, op, rhs) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -52,7 +52,7 @@ export class JoinBuilder {
     onExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -64,7 +64,7 @@ export class JoinBuilder {
     onNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'And', parseNotExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -76,7 +76,7 @@ export class JoinBuilder {
     orOnExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -88,7 +88,7 @@ export class JoinBuilder {
     orOnNotExists(arg) {
         return new JoinBuilder({
             ...this.#props,
-            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, 'Or', parseNotExistFilter(this.#props.parseContext, arg)),
+            joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     toOperationNode() {

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

@@ -3,13 +3,10 @@ import { parseJoin, } from '../parser/join-parser.js';
 import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
 import { parseExistFilter, parseReferenceFilter, parseWhereFilter, parseHavingFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
 import { parseInsertObjectOrList, } from '../parser/insert-values-parser.js';
-import { parseReferenceExpressionOrList, } from '../parser/reference-parser.js';
-import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
 import { SelectQueryNode } from '../operation-node/select-query-node.js';
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { QueryNode, } from '../operation-node/query-node.js';
-import { parseOrderByDirectionExpression, parseOrderByExpression, } from '../parser/order-by-parser.js';
-import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
+import { parseOrderBy, } from '../parser/order-by-parser.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { parseUpdateObject, } from '../parser/update-set-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
@@ -19,6 +16,7 @@ import { parseOnConflictDoNothing, parseOnConflictUpdate, } from '../parser/on-c
 import { freeze } from '../util/object-utils.js';
 import { DeleteQueryNode } from '../operation-node/delete-query-node.js';
 import { OnDuplicateKeyNode } from '../operation-node/on-duplicate-key-node.js';
+import { parseGroupBy } from '../parser/group-by-parser.js';
 /**
  * The main query builder class.
  *
@@ -43,7 +41,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseWhereFilter(this.#props.parseContext, args)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseWhereFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -101,14 +99,14 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     orWhere(...args) {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseWhereFilter(this.#props.parseContext, args)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseWhereFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -121,7 +119,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -187,7 +185,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseExistFilter(this.#props.parseContext, arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -197,7 +195,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'And', parseNotExistFilter(this.#props.parseContext, arg)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -207,7 +205,7 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseExistFilter(this.#props.parseContext, arg)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -217,14 +215,14 @@ export class QueryBuilder {
         assertCanHaveWhereClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, 'Or', parseNotExistFilter(this.#props.parseContext, arg)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     having(...args) {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseHavingFilter(this.#props.parseContext, args)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseHavingFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -235,14 +233,14 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     orHaving(...args) {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseHavingFilter(this.#props.parseContext, args)),
+            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseHavingFilter(this.#props.parseContext, args)),
         });
     }
     /**
@@ -253,7 +251,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
         });
     }
     /**
@@ -264,7 +262,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseExistFilter(this.#props.parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -275,7 +273,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'And', parseNotExistFilter(this.#props.parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -286,7 +284,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseExistFilter(this.#props.parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseExistFilter(this.#props.parseContext, arg)),
         });
     }
     /**
@@ -297,7 +295,7 @@ export class QueryBuilder {
         assertCanHaveHavingClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithHaving(this.#props.queryNode, 'Or', parseNotExistFilter(this.#props.parseContext, arg)),
+            queryNode: SelectQueryNode.cloneWithOrHaving(this.#props.queryNode, parseNotExistFilter(this.#props.parseContext, arg)),
         });
     }
     select(selection) {
@@ -714,14 +712,14 @@ export class QueryBuilder {
         assertCanHaveOrderByClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, OrderByItemNode.create(parseOrderByExpression(this.#props.parseContext, orderBy), parseOrderByDirectionExpression(direction))),
+            queryNode: SelectQueryNode.cloneWithOrderByItem(this.#props.queryNode, parseOrderBy(this.#props.parseContext, orderBy, direction)),
         });
     }
     groupBy(orderBy) {
         assertCanHaveGroupByClause(this.#props.queryNode);
         return new QueryBuilder({
             ...this.#props,
-            queryNode: SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, parseReferenceExpressionOrList(this.#props.parseContext, orderBy).map(GroupByItemNode.create)),
+            queryNode: SelectQueryNode.cloneWithGroupByItems(this.#props.queryNode, parseGroupBy(this.#props.parseContext, orderBy)),
         });
     }
     /**
@@ -958,7 +956,7 @@ function assertCanHaveUpdates(node) {
 }
 function assertCanHaveReturningClause(node) {
     if (!QueryNode.isMutating(node)) {
-        throw new Error('only an insert, delete and update queries can have a returning clause');
+        throw new Error('only insert, delete and update queries can have a returning clause');
     }
 }
 function assertCanHaveOrderByClause(node) {

package/dist/esm/query-compiler/compiled-query.d.ts

@@ -1,4 +1,4 @@
 export interface CompiledQuery {
     readonly sql: string;
-    readonly parameters: ReadonlyArray<any>;
+    readonly parameters: ReadonlyArray<unknown>;
 }

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -126,10 +126,10 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitAddConstraint(node: AddConstraintNode): void;
     protected visitDropConstraint(node: DropConstraintNode): void;
     protected append(str: string): void;
-    protected appendValue(value: PrimitiveValue): void;
+    protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;
     protected getCurrentParameterPlaceholder(): string;
-    protected addParameter(parameter: any): void;
+    protected addParameter(parameter: unknown): void;
     protected appendImmediateValue(value: PrimitiveValue): void;
 }

package/dist/esm/query-compiler/default-query-compiler.js

@@ -630,8 +630,8 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     append(str) {
         this.#sql += str;
     }
-    appendValue(value) {
-        this.addParameter(value);
+    appendValue(parameter) {
+        this.addParameter(parameter);
         this.append(this.getCurrentParameterPlaceholder());
     }
     getLeftIdentifierWrapper() {

package/dist/esm/util/object-utils.d.ts

@@ -1,16 +1,16 @@
 /// <reference types="node" />
 export declare type PrimitiveValue = string | number | boolean | null | Date | Buffer | BigInt;
-export declare function isEmpty(obj: ArrayLike<any> | string | object | Buffer): boolean;
-export declare function isString(obj: any): obj is string;
-export declare function isNumber(obj: any): obj is number;
-export declare function isBoolean(obj: any): obj is boolean;
-export declare function isNull(obj: any): obj is null;
-export declare function isDate(obj: any): obj is Date;
-export declare function isBuffer(obj: any): obj is Buffer;
-export declare function isBigInt(obj: any): obj is BigInt;
-export declare function isPrimitive(obj: any): obj is PrimitiveValue;
-export declare function isFunction(obj: any): obj is Function;
-export declare function isObject(obj: any): obj is Record<string, any>;
+export declare function isEmpty(obj: ArrayLike<unknown> | string | object | Buffer): boolean;
+export declare function isString(obj: unknown): obj is string;
+export declare function isNumber(obj: unknown): obj is number;
+export declare function isBoolean(obj: unknown): obj is boolean;
+export declare function isNull(obj: unknown): obj is null;
+export declare function isDate(obj: unknown): obj is Date;
+export declare function isBuffer(obj: unknown): obj is Buffer;
+export declare function isBigInt(obj: unknown): obj is BigInt;
+export declare function isPrimitive(obj: unknown): obj is PrimitiveValue;
+export declare function isFunction(obj: unknown): obj is Function;
+export declare function isObject(obj: unknown): obj is Record<string, unknown>;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
 export declare function freeze<T>(obj: T): Readonly<T>;
 export declare function asArray<T>(arg: T | T[]): T[];

package/dist/esm/util/object-utils.js

@@ -41,7 +41,7 @@ export function isFunction(obj) {
     return typeof obj === 'function';
 }
 export function isObject(obj) {
-    return obj && typeof obj === 'object';
+    return typeof obj === 'object' && obj !== null;
 }
 export function getLast(arr) {
     return arr[arr.length - 1];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",