kysely 0.8.0 → 0.9.2

package/README.md

@@ -4,7 +4,8 @@
 # [Kysely](https://koskimas.github.io/kysely/index.html)
 
 A type-safe and autocompletion-friendly typescript SQL query builder for node.js. Inspired by
-[knex](http://knexjs.org/).
+[knex](http://knexjs.org/). [Here's](https://www.jakso.me/blog/kysely-a-type-safe-sql-query-builder-for-typescript)
+an introductory blog post for you.
 
 ![](https://github.com/koskimas/kysely/blob/master/assets/demo.gif)
 
@@ -25,9 +26,8 @@ type-safety! See the [DynamicModule](https://koskimas.github.io/kysely/classes/D
 for more info.
 
 Kysely is still young and some useful features are propably not yet implemented. If you start
-using Kysely and can't find something you'd want to use, please open an issue.
-
-[Here](https://www.jakso.me/blog/kysely-a-type-safe-sql-query-builder-for-typescript)'s an introductory blog post about Kysely.
+using Kysely and can't find something you'd want to use, please open an issue or join our
+[discord server](https://discord.gg/C9aJ49mCra).
 
 # Table of contents
 
@@ -114,8 +114,6 @@ async function demo() {
 
 # Query examples
 
-The [API documentation](https://koskimas.github.io/kysely/index.html) is full of examples.
-
 ## Select queries
 
 You can find examples of select queries in the documentation of the 
@@ -165,13 +163,15 @@ changes completely. Migrations need to be "frozen in time".
 The migrations can use the [Kysely.schema](https://koskimas.github.io/kysely/classes/SchemaModule.html)
 module to modify the schema. Migrations can also run normal queries to modify the data.
 
+### PostgreSQL migration example
+
 ```ts
 import { Kysely } from 'kysely'
 
 export async function up(db: Kysely<any>): Promise<void> {
   await db.schema
     .createTable('person')
-    .addColumn('id', 'integer', (col) => col.increments().primaryKey())
+    .addColumn('id', 'serial', (col) => col.primaryKey())
     .addColumn('first_name', 'varchar')
     .addColumn('last_name', 'varchar')
     .addColumn('gender', 'varchar(50)')
@@ -179,7 +179,7 @@ export async function up(db: Kysely<any>): Promise<void> {
 
   await db.schema
     .createTable('pet')
-    .addColumn('id', 'integer', (col) => col.increments().primaryKey())
+    .addColumn('id', 'serial', (col) => col.primaryKey())
     .addColumn('name', 'varchar', (col) => col.notNull().unique())
     .addColumn('owner_id', 'integer', (col) =>
       col.references('person.id').onDelete('cascade')
@@ -200,6 +200,45 @@ export async function down(db: Kysely<any>): Promise<void> {
 }
 ```
 
+### MySQL migration example
+
+```ts
+import { Kysely } from 'kysely'
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable('person')
+    .addColumn('id', 'integer', (col) => col.increments().primaryKey())
+    .addColumn('first_name', 'varchar')
+    .addColumn('last_name', 'varchar')
+    .addColumn('gender', 'varchar(50)')
+    .execute()
+
+  await db.schema
+    .createTable('pet')
+    .addColumn('id', 'integer', (col) => col.increments().primaryKey())
+    .addColumn('name', 'varchar', (col) => col.notNull().unique())
+    .addColumn('owner_id', 'integer')
+    .addColumn('species', 'varchar')
+    .addForeignKeyConstraint(
+      'pet_owner_id_fk', ['owner_id'], 'person', ['id'],
+      (cb) => cb.onDelete('cascade')
+    )
+    .execute()
+
+  await db.schema
+    .createIndex('pet_owner_id_index')
+    .on('pet')
+    .column('owner_id')
+    .execute()
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema.dropTable('pet').execute()
+  await db.schema.dropTable('person').execute()
+}
+```
+
 You can then use
 
 ```ts

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

@@ -53,16 +53,16 @@ class MysqlDriver {
             // On mysql this sets the isolation level of the next transaction.
             await connection.executeQuery({
                 sql: `set transaction isolation level ${settings.isolationLevel}`,
-                bindings: [],
+                parameters: [],
             });
         }
-        await connection.executeQuery({ sql: 'begin', bindings: [] });
+        await connection.executeQuery({ sql: 'begin', parameters: [] });
     }
     async commitTransaction(connection) {
-        await connection.executeQuery({ sql: 'commit', bindings: [] });
+        await connection.executeQuery({ sql: 'commit', parameters: [] });
     }
     async rollbackTransaction(connection) {
-        await connection.executeQuery({ sql: 'rollback', bindings: [] });
+        await connection.executeQuery({ sql: 'rollback', parameters: [] });
     }
     async releaseConnection(connection) {
         const mysqlConnection = connection;
@@ -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: [],
@@ -131,7 +131,7 @@ class MysqlConnection {
     }
     #executeQuery(compiledQuery) {
         return new Promise((resolve, reject) => {
-            this.#rawConnection.query(compiledQuery.sql, compiledQuery.bindings, (err, result) => {
+            this.#rawConnection.query(compiledQuery.sql, compiledQuery.parameters, (err, result) => {
                 if (err) {
                     reject(err);
                 }

package/dist/cjs/dialect/mysql/mysql-query-compiler.d.ts

@@ -1,7 +1,5 @@
-import { ColumnDefinitionNode } from '../../operation-node/column-definition-node.js';
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class MysqlQueryCompiler extends DefaultQueryCompiler {
-    protected visitColumnDefinition(node: ColumnDefinitionNode): void;
     protected visitReturning(): void;
     protected getSql(): string;
     protected getCurrentParameterPlaceholder(): string;

package/dist/cjs/dialect/mysql/mysql-query-compiler.js

@@ -3,35 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlQueryCompiler = void 0;
 const default_query_compiler_js_1 = require("../../query-compiler/default-query-compiler.js");
 class MysqlQueryCompiler extends default_query_compiler_js_1.DefaultQueryCompiler {
-    visitColumnDefinition(node) {
-        this.visitNode(node.column);
-        this.append(' ');
-        this.visitNode(node.dataType);
-        if (node.defaultTo) {
-            this.append(' default ');
-            this.visitNode(node.defaultTo);
-        }
-        if (!node.isNullable || node.isAutoIncrementing) {
-            this.append(' not null');
-        }
-        if (node.isAutoIncrementing) {
-            this.append(' auto_increment');
-        }
-        if (node.isUnique) {
-            this.append(' unique');
-        }
-        if (node.isPrimaryKey) {
-            this.append(' primary key');
-        }
-        if (node.references) {
-            this.append(' ');
-            this.visitNode(node.references);
-        }
-        if (node.check) {
-            this.append(' ');
-            this.visitNode(node.check);
-        }
-    }
     visitReturning() {
         // Do nothing.
     }

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

@@ -40,18 +40,18 @@ class PostgresDriver {
         if (settings.isolationLevel) {
             await connection.executeQuery({
                 sql: `start transaction isolation level ${settings.isolationLevel}`,
-                bindings: [],
+                parameters: [],
             });
         }
         else {
-            await connection.executeQuery({ sql: 'begin', bindings: [] });
+            await connection.executeQuery({ sql: 'begin', parameters: [] });
         }
     }
     async commitTransaction(connection) {
-        await connection.executeQuery({ sql: 'commit', bindings: [] });
+        await connection.executeQuery({ sql: 'commit', parameters: [] });
     }
     async rollbackTransaction(connection) {
-        await connection.executeQuery({ sql: 'rollback', bindings: [] });
+        await connection.executeQuery({ sql: 'rollback', parameters: [] });
     }
     async releaseConnection(connection) {
         const pgConnection = connection;
@@ -90,7 +90,7 @@ class PostgresConnection {
     }
     async executeQuery(compiledQuery) {
         const result = await this.#client.query(compiledQuery.sql, [
-            ...compiledQuery.bindings,
+            ...compiledQuery.parameters,
         ]);
         if (result.command === 'UPDATE' || result.command === 'DELETE') {
             return {

package/dist/cjs/operation-node/create-schema-node.d.ts

@@ -13,5 +13,5 @@ export interface CreateSchemaNode extends OperationNode {
 export declare const CreateSchemaNode: Readonly<{
     is(node: OperationNode): node is CreateSchemaNode;
     create(schema: string, params?: CreateSchemaNodeParams | undefined): CreateSchemaNode;
-    cloneWithModifier(createSchema: CreateSchemaNode, modifier: CreateSchemaNodeModifier): CreateSchemaNode;
+    cloneWith(createSchema: CreateSchemaNode, params: CreateSchemaNodeParams): CreateSchemaNode;
 }>;

package/dist/cjs/operation-node/create-schema-node.js

@@ -17,10 +17,10 @@ exports.CreateSchemaNode = (0, object_utils_js_1.freeze)({
             ...params,
         });
     },
-    cloneWithModifier(createSchema, modifier) {
+    cloneWith(createSchema, params) {
         return (0, object_utils_js_1.freeze)({
             ...createSchema,
-            modifier,
+            ...params,
         });
     },
 });

package/dist/cjs/operation-node/create-table-node.d.ts

@@ -1,6 +1,5 @@
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
-import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ConstraintNode } from './constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 export declare type CreateTableNodeModifier = 'IfNotExists';
@@ -19,8 +18,5 @@ export declare const CreateTableNode: Readonly<{
     create(table: TableNode): CreateTableNode;
     cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): CreateTableNode;
     cloneWithModifier(createTable: CreateTableNode, modifier: CreateTableNodeModifier): CreateTableNode;
-    cloneWithPrimaryKeyConstraint(createTable: CreateTableNode, constraintName: string, columns: string[]): CreateTableNode;
-    cloneWithUniqueConstraint(createTable: CreateTableNode, constraintName: string, columns: string[]): CreateTableNode;
-    cloneWithCheckConstraint(createTable: CreateTableNode, constraintName: string, sql: string): CreateTableNode;
-    cloneWithForeignKeyConstraint(createTable: CreateTableNode, constraint: ForeignKeyConstraintNode): CreateTableNode;
+    cloneWithConstraint(createTable: CreateTableNode, constraint: ConstraintNode): CreateTableNode;
 }>;

package/dist/cjs/operation-node/create-table-node.js

@@ -2,9 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateTableNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
-const check_constraint_node_js_1 = require("./check-constraint-node.js");
-const primary_constraint_node_js_1 = require("./primary-constraint-node.js");
-const unique_constraint_node_js_1 = require("./unique-constraint-node.js");
 /**
  * @internal
  */
@@ -31,34 +28,7 @@ exports.CreateTableNode = (0, object_utils_js_1.freeze)({
             modifier,
         });
     },
-    cloneWithPrimaryKeyConstraint(createTable, constraintName, columns) {
-        const constraint = primary_constraint_node_js_1.PrimaryConstraintNode.create(columns, constraintName);
-        return (0, object_utils_js_1.freeze)({
-            ...createTable,
-            constraints: createTable.constraints
-                ? (0, object_utils_js_1.freeze)([...createTable.constraints, constraint])
-                : (0, object_utils_js_1.freeze)([constraint]),
-        });
-    },
-    cloneWithUniqueConstraint(createTable, constraintName, columns) {
-        const constraint = unique_constraint_node_js_1.UniqueConstraintNode.create(columns, constraintName);
-        return (0, object_utils_js_1.freeze)({
-            ...createTable,
-            constraints: createTable.constraints
-                ? (0, object_utils_js_1.freeze)([...createTable.constraints, constraint])
-                : (0, object_utils_js_1.freeze)([constraint]),
-        });
-    },
-    cloneWithCheckConstraint(createTable, constraintName, sql) {
-        const constraint = check_constraint_node_js_1.CheckConstraintNode.create(sql, constraintName);
-        return (0, object_utils_js_1.freeze)({
-            ...createTable,
-            constraints: createTable.constraints
-                ? (0, object_utils_js_1.freeze)([...createTable.constraints, constraint])
-                : (0, object_utils_js_1.freeze)([constraint]),
-        });
-    },
-    cloneWithForeignKeyConstraint(createTable, constraint) {
+    cloneWithConstraint(createTable, constraint) {
         return (0, object_utils_js_1.freeze)({
             ...createTable,
             constraints: createTable.constraints

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/operation-node-source.d.ts

@@ -2,4 +2,4 @@ import { OperationNode } from './operation-node.js';
 export interface OperationNodeSource {
     toOperationNode(): OperationNode;
 }
-export declare function isOperationNodeSource(obj: any): obj is OperationNodeSource;
+export declare function isOperationNodeSource(obj: unknown): obj is OperationNodeSource;

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

@@ -456,11 +456,12 @@ class OperationNodeTransformer {
             kind: 'AlterTableNode',
             table: this.transformNode(node.table),
             renameTo: this.transformNode(node.renameTo),
-            renameColumn: this.transformNode(node.renameColumn),
             setSchema: this.transformNode(node.setSchema),
+            renameColumn: this.transformNode(node.renameColumn),
             addColumn: this.transformNode(node.addColumn),
             dropColumn: this.transformNode(node.dropColumn),
             alterColumn: this.transformNode(node.alterColumn),
+            modifyColumn: this.transformNode(node.modifyColumn),
             addConstraint: this.transformNode(node.addConstraint),
             dropConstraint: this.transformNode(node.dropConstraint),
         };

package/dist/cjs/operation-node/primitive-value-list-node.js

@@ -12,7 +12,7 @@ exports.PrimitiveValueListNode = (0, object_utils_js_1.freeze)({
     create(values) {
         return (0, object_utils_js_1.freeze)({
             kind: 'PrimitiveValueListNode',
-            values: (0, object_utils_js_1.freeze)(values),
+            values: (0, object_utils_js_1.freeze)([...values]),
         });
     },
 });

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/join-parser.d.ts

@@ -1,8 +1,11 @@
 import { JoinNode, JoinType } from '../operation-node/join-node.js';
 import { AnyColumn, AnyColumnWithTable } from '../util/type-utils.js';
-import { ExtractAliasFromTableExpression, TableExpressionDatabaseType } from './table-parser.js';
+import { ExtractAliasFromTableExpression, TableExpressionDatabase } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 import { ParseContext } from './parse-context.js';
-export declare type JoinReferenceExpression<DB, TB extends keyof DB, F> = AnyColumn<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>> | AnyColumnWithTable<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
-export declare type JoinCallbackExpression<DB, TB extends keyof DB, F> = (join: JoinBuilder<TableExpressionDatabaseType<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>) => JoinBuilder<any, any>;
+export declare type JoinReferenceExpression<DB, TB extends keyof DB, F> = AnyJoinColumn<DB, TB, F> | AnyJoinColumnWithTable<DB, TB, F>;
+export declare type JoinCallbackExpression<DB, TB extends keyof DB, F> = (join: JoinBuilder<TableExpressionDatabase<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>) => JoinBuilder<any, any>;
+declare type AnyJoinColumn<DB, TB extends keyof DB, F> = AnyColumn<TableExpressionDatabase<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
+declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, F> = AnyColumnWithTable<TableExpressionDatabase<DB, F>, TB | ExtractAliasFromTableExpression<DB, F>>;
 export declare function parseJoin(ctx: ParseContext, joinType: JoinType, args: any[]): JoinNode;
+export {};

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/parser/table-parser.d.ts

@@ -7,20 +7,20 @@ import { ParseContext } from './parse-context.js';
 export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export declare type TableReference<DB> = AnyAliasedTable<DB, any, any> | AnyTable<DB> | AnyAliasedRawBuilder;
-export declare type QueryBuilderWithTable<DB, TB extends keyof DB, O, TE> = QueryBuilder<TableExpressionDatabaseType<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
-export declare type TableExpressionDatabaseType<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
+export declare type QueryBuilderWithTable<DB, TB extends keyof DB, O, TE> = QueryBuilder<TableExpressionDatabase<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
+export declare type TableExpressionDatabase<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
     [C in keyof DB | A]: C extends A ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 };
-export declare type QueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<LeftJoinTableExpressionDatabaseType<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
-export declare type LeftJoinTableExpressionDatabaseType<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
+export declare type QueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<LeftJoinTableExpressionDatabase<DB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
+export declare type LeftJoinTableExpressionDatabase<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
     [C in keyof DB | A]: C extends A ? Nullable<ExtractRowTypeFromTableExpression<DB, TE, C>> : C extends keyof DB ? DB[C] : never;
 };
-export declare type QueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<RightJoinTableExpressionDatabaseType<DB, TB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
-export declare type RightJoinTableExpressionDatabaseType<DB, TB extends keyof DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
+export declare type QueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<RightJoinTableExpressionDatabase<DB, TB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
+export declare type RightJoinTableExpressionDatabase<DB, TB extends keyof DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
     [C in keyof DB | A]: C extends A ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? C extends TB ? Nullable<DB[C]> : DB[C] : never;
 };
-export declare type QueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<FullJoinTableExpressionDatabaseType<DB, TB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
-export declare type FullJoinTableExpressionDatabaseType<DB, TB extends keyof DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
+export declare type QueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE> = QueryBuilder<FullJoinTableExpressionDatabase<DB, TB, TE>, TB | ExtractAliasFromTableExpression<DB, TE>, O>;
+export declare type FullJoinTableExpressionDatabase<DB, TB extends keyof DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
     [C in keyof DB | A]: C extends A ? Nullable<ExtractRowTypeFromTableExpression<DB, TE, C>> : C extends keyof DB ? C extends TB ? Nullable<DB[C]> : DB[C] : never;
 };
 export declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends AliasedRawBuilder<any, infer RA> ? RA : TE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : never;

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

@@ -66,9 +66,9 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * Calls the `sum` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string` by default. This is because Kysely can't know the
-     * type the db driver outputs. Sometimes the output can be larger than the
-     * largest javascript number and a string is returned instead. Most drivers
+     * will be `number | string | BigInt` by default. This is because Kysely can't
+     * know the type the db driver outputs. Sometimes the output can be larger than
+     * the largest javascript number and a string is returned instead. Most drivers
      * allow you to configure the output type of large numbers and Kysely can't
      * know if you've done so.
      *
@@ -88,9 +88,9 @@ export declare class FunctionBuilder<DB, TB extends keyof DB> {
      * Calls the `count` function for the column given as the argument.
      *
      * If this is used in a `select` statement the type of the selected expression
-     * will be `number | string` by default. This is because Kysely can't know the
-     * type the db driver outputs. Sometimes the output can be larger than the
-     * largest javascript number and a string is returned instead. Most drivers
+     * will be `number | string | BigInt` by default. This is because Kysely can't
+     * know the type the db driver outputs. Sometimes the output can be larger than
+     * the largest javascript number and a string is returned instead. Most drivers
      * allow you to configure the output type of large numbers and Kysely can't
      * know if you've done so.
      *