kysely 0.28.9 → 0.28.11

package/README.md

@@ -6,7 +6,9 @@
 [![Issues](https://img.shields.io/github/issues-closed/kysely-org/kysely?logo=github)](https://github.com/kysely-org/kysely/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc)
 [![Pull Requests](https://img.shields.io/github/issues-pr-closed/kysely-org/kysely?label=PRs&logo=github&style=flat)](https://github.com/kysely-org/kysely/pulls?q=is%3Apr+is%3Aopen+sort%3Aupdated-desc)
 ![GitHub contributors](https://img.shields.io/github/contributors/kysely-org/kysely)
-[![Downloads](https://img.shields.io/npm/dw/kysely?logo=npm)](https://www.npmjs.com/package/kysely)
+[![NPM Downloads](https://img.shields.io/npm/dw/kysely?logo=npm)](https://www.npmjs.com/package/kysely)
+[![JSR Downloads](https://jsr.io/badges/@kysely/kysely/weekly-downloads)](https://jsr.io/@kysely/kysely)
+[![JSR Score](https://jsr.io/badges/@kysely/kysely/score)](https://jsr.io/@kysely/kysely)
 
 ###### Join the discussion ⠀⠀⠀⠀⠀⠀⠀ 
 [![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?style=flat&logo=discord&logoColor=white)](https://discord.gg/xyBJ3GwvAm)

package/dist/cjs/index.d.ts

@@ -206,10 +206,11 @@ export * from './util/compilable.js';
 export * from './util/explainable.js';
 export * from './util/streamable.js';
 export * from './util/log.js';
-export type { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, Equals, UnknownRow, Simplify, SqlBool, Nullable, NumbersWhenDataTypeNotAvailable, NotNull, NumericString, ShallowDehydrateObject, ShallowDehydrateValue, StringsWhenDataTypeNotAvailable, } from './util/type-utils.js';
+export type { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, DrainOuterGeneric, Equals, ExtractColumnType, UnknownRow, Simplify, SqlBool, Nullable, NumbersWhenDataTypeNotAvailable, NotNull, NumericString, ShallowDehydrateObject, ShallowDehydrateValue, SimplifyResult, SimplifySingleResult, StringsWhenDataTypeNotAvailable, } from './util/type-utils.js';
 export * from './util/infer-result.js';
 export { logOnce } from './util/log-once.js';
 export { createQueryId, type QueryId } from './util/query-id.js';
+export type { KyselyTypeError } from './util/type-error.js';
 export type { SelectExpression, SelectCallback, SelectArg, Selection, CallbackSelection, } from './parser/select-parser.js';
 export type { ReferenceExpression, ReferenceExpressionOrList, SimpleReferenceExpression, StringReference, ExtractTypeFromStringReference, ExtractTypeFromReferenceExpression, } from './parser/reference-parser.js';
 export type { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.js';
@@ -222,3 +223,4 @@ export type { ComparisonOperatorExpression, OperandValueExpression, OperandValue
 export type { ExistsExpression } from './parser/unary-operation-parser.js';
 export type { OperandExpression, ExpressionOrFactory, } from './parser/expression-parser.js';
 export type { Collation } from './parser/collate-parser.js';
+export type { QueryCreatorWithCommonTableExpression } from './parser/with-parser.js';

package/dist/cjs/kysely.js

@@ -565,7 +565,8 @@ class TransactionBuilder {
         const settings = { isolationLevel, accessMode };
         (0, driver_js_1.validateTransactionSettings)(settings);
         return this.#props.executor.provideConnection(async (connection) => {
-            const executor = this.#props.executor.withConnectionProvider(new single_connection_provider_js_1.SingleConnectionProvider(connection));
+            const state = { isCommitted: false, isRolledBack: false };
+            const executor = new NotCommittedOrRolledBackAssertingExecutor(this.#props.executor.withConnectionProvider(new single_connection_provider_js_1.SingleConnectionProvider(connection)), state);
             const transaction = new Transaction({
                 ...kyselyProps,
                 executor,
@@ -576,11 +577,13 @@ class TransactionBuilder {
                 transactionBegun = true;
                 const result = await callback(transaction);
                 await this.#props.driver.commitTransaction(connection);
+                state.isCommitted = true;
                 return result;
             }
             catch (error) {
                 if (transactionBegun) {
                     await this.#props.driver.rollbackTransaction(connection);
+                    state.isRolledBack = true;
                 }
                 throw error;
             }

package/dist/cjs/migration/migrator.d.ts

@@ -263,7 +263,7 @@ export interface MigratorProps {
      * the project, to the end of time or prepare to manually migrate the migration
      * tables.
      *
-     * This only works on postgres.
+     * This only works on postgres and mssql.
      */
     readonly migrationTableSchema?: string;
     /**

package/dist/cjs/migration/migrator.js

@@ -58,7 +58,8 @@ class Migrator {
      * The returned array is sorted by migration name.
      */
     async getMigrations() {
-        const executedMigrations = (await this.#doesTableExists(this.#migrationTable))
+        const tableExists = await this.#doesTableExist(this.#migrationTable);
+        const executedMigrations = tableExists
             ? await this.#props.db
                 .withPlugin(this.#schemaPlugin)
                 .selectFrom(this.#migrationTable)
@@ -265,7 +266,10 @@ class Migrator {
     }
     async #migrate(getMigrationDirectionAndStep) {
         try {
-            await this.#ensureMigrationTablesExists();
+            await this.#ensureMigrationTableSchemaExists();
+            await this.#ensureMigrationTableExists();
+            await this.#ensureMigrationLockTableExists();
+            await this.#ensureLockRowExists();
             return await this.#runMigrations(getMigrationDirectionAndStep);
         }
         catch (error) {
@@ -293,95 +297,98 @@ class Migrator {
         }
         return new noop_plugin_js_1.NoopPlugin();
     }
-    async #ensureMigrationTablesExists() {
-        await this.#ensureMigrationTableSchemaExists();
-        await this.#ensureMigrationTableExists();
-        await this.#ensureMigrationLockTableExists();
-        await this.#ensureLockRowExists();
-    }
     async #ensureMigrationTableSchemaExists() {
         if (!this.#migrationTableSchema) {
             // Use default schema. Nothing to do.
             return;
         }
-        if (!(await this.#doesSchemaExists())) {
-            try {
-                await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
-                // query doesn't throw if the schema already exits. That's why we check if
-                // the schema exist here and ignore the error if it does.
-                if (!(await this.#doesSchemaExists())) {
-                    throw error;
-                }
+        const schemaExists = await this.#doesSchemaExist();
+        if (schemaExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
+        }
+        catch (error) {
+            const schemaExists = await this.#doesSchemaExist();
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
+            // query doesn't throw if the schema already exits. That's why we check if
+            // the schema exist here and ignore the error if it does.
+            if (!schemaExists) {
+                throw error;
             }
         }
     }
     async #ensureMigrationTableExists() {
-        if (!(await this.#doesTableExists(this.#migrationTable))) {
-            try {
-                if (this.#migrationTableSchema) {
-                    await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
-                }
-                await this.#createIfNotExists(this.#props.db.schema
-                    .withPlugin(this.#schemaPlugin)
-                    .createTable(this.#migrationTable)
-                    .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
-                    // The migration run time as ISO string. This is not a real date type as we
-                    // can't know which data type is supported by all future dialects.
-                    .addColumn('timestamp', 'varchar(255)', (col) => col.notNull()));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-                // query doesn't throw if the table already exits. That's why we check if
-                // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(this.#migrationTable))) {
-                    throw error;
-                }
+        const tableExists = await this.#doesTableExist(this.#migrationTable);
+        if (tableExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema
+                .withPlugin(this.#schemaPlugin)
+                .createTable(this.#migrationTable)
+                .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
+                // The migration run time as ISO string. This is not a real date type as we
+                // can't know which data type is supported by all future dialects.
+                .addColumn('timestamp', 'varchar(255)', (col) => col.notNull()));
+        }
+        catch (error) {
+            const tableExists = await this.#doesTableExist(this.#migrationTable);
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+            // query doesn't throw if the table already exits. That's why we check if
+            // the table exist here and ignore the error if it does.
+            if (!tableExists) {
+                throw error;
             }
         }
     }
     async #ensureMigrationLockTableExists() {
-        if (!(await this.#doesTableExists(this.#migrationLockTable))) {
-            try {
-                await this.#createIfNotExists(this.#props.db.schema
-                    .withPlugin(this.#schemaPlugin)
-                    .createTable(this.#migrationLockTable)
-                    .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
-                    .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0)));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-                // query doesn't throw if the table already exits. That's why we check if
-                // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(this.#migrationLockTable))) {
-                    throw error;
-                }
+        const tableExists = await this.#doesTableExist(this.#migrationLockTable);
+        if (tableExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema
+                .withPlugin(this.#schemaPlugin)
+                .createTable(this.#migrationLockTable)
+                .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
+                .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0)));
+        }
+        catch (error) {
+            const tableExists = await this.#doesTableExist(this.#migrationLockTable);
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+            // query doesn't throw if the table already exits. That's why we check if
+            // the table exist here and ignore the error if it does.
+            if (!tableExists) {
+                throw error;
             }
         }
     }
     async #ensureLockRowExists() {
-        if (!(await this.#doesLockRowExists())) {
-            try {
-                await this.#props.db
-                    .withPlugin(this.#schemaPlugin)
-                    .insertInto(this.#migrationLockTable)
-                    .values({ id: exports.MIGRATION_LOCK_ID, is_locked: 0 })
-                    .execute();
-            }
-            catch (error) {
-                if (!(await this.#doesLockRowExists())) {
-                    throw error;
-                }
+        const lockRowExists = await this.#doesLockRowExists();
+        if (lockRowExists) {
+            return;
+        }
+        try {
+            await this.#props.db
+                .withPlugin(this.#schemaPlugin)
+                .insertInto(this.#migrationLockTable)
+                .values({ id: exports.MIGRATION_LOCK_ID, is_locked: 0 })
+                .execute();
+        }
+        catch (error) {
+            const lockRowExists = await this.#doesLockRowExists();
+            if (!lockRowExists) {
+                throw error;
             }
         }
     }
-    async #doesSchemaExists() {
+    async #doesSchemaExist() {
         const schemas = await this.#props.db.introspection.getSchemas();
         return schemas.some((it) => it.name === this.#migrationTableSchema);
     }
-    async #doesTableExists(tableName) {
+    async #doesTableExist(tableName) {
         const schema = this.#migrationTableSchema;
         const tables = await this.#props.db.introspection.getTables({
             withInternalKyselyTables: true,

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

@@ -581,6 +581,10 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' ');
             this.visitNode(node.where);
         }
+        if (node.returning) {
+            this.append(' ');
+            this.visitNode(node.returning);
+        }
         if (node.orderBy) {
             this.append(' ');
             this.visitNode(node.orderBy);
@@ -589,10 +593,6 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' ');
             this.visitNode(node.limit);
         }
-        if (node.returning) {
-            this.append(' ');
-            this.visitNode(node.returning);
-        }
         if (wrapInParens) {
             this.append(')');
         }

package/dist/esm/index.d.ts

@@ -206,10 +206,11 @@ export * from './util/compilable.js';
 export * from './util/explainable.js';
 export * from './util/streamable.js';
 export * from './util/log.js';
-export type { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, Equals, UnknownRow, Simplify, SqlBool, Nullable, NumbersWhenDataTypeNotAvailable, NotNull, NumericString, ShallowDehydrateObject, ShallowDehydrateValue, StringsWhenDataTypeNotAvailable, } from './util/type-utils.js';
+export type { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, DrainOuterGeneric, Equals, ExtractColumnType, UnknownRow, Simplify, SqlBool, Nullable, NumbersWhenDataTypeNotAvailable, NotNull, NumericString, ShallowDehydrateObject, ShallowDehydrateValue, SimplifyResult, SimplifySingleResult, StringsWhenDataTypeNotAvailable, } from './util/type-utils.js';
 export * from './util/infer-result.js';
 export { logOnce } from './util/log-once.js';
 export { createQueryId, type QueryId } from './util/query-id.js';
+export type { KyselyTypeError } from './util/type-error.js';
 export type { SelectExpression, SelectCallback, SelectArg, Selection, CallbackSelection, } from './parser/select-parser.js';
 export type { ReferenceExpression, ReferenceExpressionOrList, SimpleReferenceExpression, StringReference, ExtractTypeFromStringReference, ExtractTypeFromReferenceExpression, } from './parser/reference-parser.js';
 export type { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.js';
@@ -222,3 +223,4 @@ export type { ComparisonOperatorExpression, OperandValueExpression, OperandValue
 export type { ExistsExpression } from './parser/unary-operation-parser.js';
 export type { OperandExpression, ExpressionOrFactory, } from './parser/expression-parser.js';
 export type { Collation } from './parser/collate-parser.js';
+export type { QueryCreatorWithCommonTableExpression } from './parser/with-parser.js';

package/dist/esm/kysely.js

@@ -559,7 +559,8 @@ export class TransactionBuilder {
         const settings = { isolationLevel, accessMode };
         validateTransactionSettings(settings);
         return this.#props.executor.provideConnection(async (connection) => {
-            const executor = this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection));
+            const state = { isCommitted: false, isRolledBack: false };
+            const executor = new NotCommittedOrRolledBackAssertingExecutor(this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection)), state);
             const transaction = new Transaction({
                 ...kyselyProps,
                 executor,
@@ -570,11 +571,13 @@ export class TransactionBuilder {
                 transactionBegun = true;
                 const result = await callback(transaction);
                 await this.#props.driver.commitTransaction(connection);
+                state.isCommitted = true;
                 return result;
             }
             catch (error) {
                 if (transactionBegun) {
                     await this.#props.driver.rollbackTransaction(connection);
+                    state.isRolledBack = true;
                 }
                 throw error;
             }

package/dist/esm/migration/migrator.d.ts

@@ -263,7 +263,7 @@ export interface MigratorProps {
      * the project, to the end of time or prepare to manually migrate the migration
      * tables.
      *
-     * This only works on postgres.
+     * This only works on postgres and mssql.
      */
     readonly migrationTableSchema?: string;
     /**

package/dist/esm/migration/migrator.js

@@ -56,7 +56,8 @@ export class Migrator {
      * The returned array is sorted by migration name.
      */
     async getMigrations() {
-        const executedMigrations = (await this.#doesTableExists(this.#migrationTable))
+        const tableExists = await this.#doesTableExist(this.#migrationTable);
+        const executedMigrations = tableExists
             ? await this.#props.db
                 .withPlugin(this.#schemaPlugin)
                 .selectFrom(this.#migrationTable)
@@ -263,7 +264,10 @@ export class Migrator {
     }
     async #migrate(getMigrationDirectionAndStep) {
         try {
-            await this.#ensureMigrationTablesExists();
+            await this.#ensureMigrationTableSchemaExists();
+            await this.#ensureMigrationTableExists();
+            await this.#ensureMigrationLockTableExists();
+            await this.#ensureLockRowExists();
             return await this.#runMigrations(getMigrationDirectionAndStep);
         }
         catch (error) {
@@ -291,95 +295,98 @@ export class Migrator {
         }
         return new NoopPlugin();
     }
-    async #ensureMigrationTablesExists() {
-        await this.#ensureMigrationTableSchemaExists();
-        await this.#ensureMigrationTableExists();
-        await this.#ensureMigrationLockTableExists();
-        await this.#ensureLockRowExists();
-    }
     async #ensureMigrationTableSchemaExists() {
         if (!this.#migrationTableSchema) {
             // Use default schema. Nothing to do.
             return;
         }
-        if (!(await this.#doesSchemaExists())) {
-            try {
-                await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
-                // query doesn't throw if the schema already exits. That's why we check if
-                // the schema exist here and ignore the error if it does.
-                if (!(await this.#doesSchemaExists())) {
-                    throw error;
-                }
+        const schemaExists = await this.#doesSchemaExist();
+        if (schemaExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
+        }
+        catch (error) {
+            const schemaExists = await this.#doesSchemaExist();
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
+            // query doesn't throw if the schema already exits. That's why we check if
+            // the schema exist here and ignore the error if it does.
+            if (!schemaExists) {
+                throw error;
             }
         }
     }
     async #ensureMigrationTableExists() {
-        if (!(await this.#doesTableExists(this.#migrationTable))) {
-            try {
-                if (this.#migrationTableSchema) {
-                    await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
-                }
-                await this.#createIfNotExists(this.#props.db.schema
-                    .withPlugin(this.#schemaPlugin)
-                    .createTable(this.#migrationTable)
-                    .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
-                    // The migration run time as ISO string. This is not a real date type as we
-                    // can't know which data type is supported by all future dialects.
-                    .addColumn('timestamp', 'varchar(255)', (col) => col.notNull()));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-                // query doesn't throw if the table already exits. That's why we check if
-                // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(this.#migrationTable))) {
-                    throw error;
-                }
+        const tableExists = await this.#doesTableExist(this.#migrationTable);
+        if (tableExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema
+                .withPlugin(this.#schemaPlugin)
+                .createTable(this.#migrationTable)
+                .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
+                // The migration run time as ISO string. This is not a real date type as we
+                // can't know which data type is supported by all future dialects.
+                .addColumn('timestamp', 'varchar(255)', (col) => col.notNull()));
+        }
+        catch (error) {
+            const tableExists = await this.#doesTableExist(this.#migrationTable);
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+            // query doesn't throw if the table already exits. That's why we check if
+            // the table exist here and ignore the error if it does.
+            if (!tableExists) {
+                throw error;
             }
         }
     }
     async #ensureMigrationLockTableExists() {
-        if (!(await this.#doesTableExists(this.#migrationLockTable))) {
-            try {
-                await this.#createIfNotExists(this.#props.db.schema
-                    .withPlugin(this.#schemaPlugin)
-                    .createTable(this.#migrationLockTable)
-                    .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
-                    .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0)));
-            }
-            catch (error) {
-                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
-                // query doesn't throw if the table already exits. That's why we check if
-                // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(this.#migrationLockTable))) {
-                    throw error;
-                }
+        const tableExists = await this.#doesTableExist(this.#migrationLockTable);
+        if (tableExists) {
+            return;
+        }
+        try {
+            await this.#createIfNotExists(this.#props.db.schema
+                .withPlugin(this.#schemaPlugin)
+                .createTable(this.#migrationLockTable)
+                .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
+                .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0)));
+        }
+        catch (error) {
+            const tableExists = await this.#doesTableExist(this.#migrationLockTable);
+            // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
+            // query doesn't throw if the table already exits. That's why we check if
+            // the table exist here and ignore the error if it does.
+            if (!tableExists) {
+                throw error;
             }
         }
     }
     async #ensureLockRowExists() {
-        if (!(await this.#doesLockRowExists())) {
-            try {
-                await this.#props.db
-                    .withPlugin(this.#schemaPlugin)
-                    .insertInto(this.#migrationLockTable)
-                    .values({ id: MIGRATION_LOCK_ID, is_locked: 0 })
-                    .execute();
-            }
-            catch (error) {
-                if (!(await this.#doesLockRowExists())) {
-                    throw error;
-                }
+        const lockRowExists = await this.#doesLockRowExists();
+        if (lockRowExists) {
+            return;
+        }
+        try {
+            await this.#props.db
+                .withPlugin(this.#schemaPlugin)
+                .insertInto(this.#migrationLockTable)
+                .values({ id: MIGRATION_LOCK_ID, is_locked: 0 })
+                .execute();
+        }
+        catch (error) {
+            const lockRowExists = await this.#doesLockRowExists();
+            if (!lockRowExists) {
+                throw error;
             }
         }
     }
-    async #doesSchemaExists() {
+    async #doesSchemaExist() {
         const schemas = await this.#props.db.introspection.getSchemas();
         return schemas.some((it) => it.name === this.#migrationTableSchema);
     }
-    async #doesTableExists(tableName) {
+    async #doesTableExist(tableName) {
         const schema = this.#migrationTableSchema;
         const tables = await this.#props.db.introspection.getTables({
             withInternalKyselyTables: true,

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

@@ -579,6 +579,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.where);
         }
+        if (node.returning) {
+            this.append(' ');
+            this.visitNode(node.returning);
+        }
         if (node.orderBy) {
             this.append(' ');
             this.visitNode(node.orderBy);
@@ -587,10 +591,6 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.limit);
         }
-        if (node.returning) {
-            this.append(' ');
-            this.visitNode(node.returning);
-        }
         if (wrapInParens) {
             this.append(')');
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.28.9",
+  "version": "0.28.11",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -76,35 +76,35 @@
   ],
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.2",
-    "@ark/attest": "^0.55.0",
+    "@ark/attest": "^0.56.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/chai": "^5.2.3",
     "@types/chai-as-promised": "^8.0.2",
     "@types/mocha": "^10.0.10",
     "@types/node": "^24.10.1",
-    "@types/pg": "^8.15.6",
+    "@types/pg": "^8.16.0",
     "@types/pg-cursor": "^2.7.2",
     "@types/semver": "^7.7.1",
-    "@types/sinon": "^17.0.4",
-    "better-sqlite3": "^12.5.0",
-    "chai": "^6.2.1",
+    "@types/sinon": "^21.0.0",
+    "better-sqlite3": "^12.6.2",
+    "chai": "^6.2.2",
     "chai-as-promised": "^8.0.2",
-    "esbuild": "^0.27.0",
-    "jsr": "^0.13.4",
-    "lodash": "^4.17.21",
+    "esbuild": "^0.27.2",
+    "jsr": "^0.14.1",
+    "lodash": "^4.17.23",
     "mocha": "^11.7.5",
-    "mysql2": "^3.15.3",
+    "mysql2": "^3.16.2",
     "pathe": "^2.0.3",
-    "pg": "^8.15.6",
-    "pg-cursor": "^2.14.6",
+    "pg": "^8.17.2",
+    "pg-cursor": "^2.16.2",
     "pkg-types": "^2.3.0",
-    "playwright": "^1.57.0",
-    "prettier": "^3.7.3",
+    "playwright": "^1.58.0",
+    "prettier": "^3.8.1",
     "semver": "^7.7.3",
-    "sinon": "^21.0.0",
+    "sinon": "^21.0.1",
     "std-env": "^3.10.0",
     "tarn": "^3.0.2",
-    "tedious": "^19.1.3",
+    "tedious": "^19.2.0",
     "tsd": "^0.33.0",
     "typescript": "~5.9.3"
   },