it works.

src/kysely.ts

@@ -33,6 +33,9 @@ import { Expression } from './expression/expression.js'
 import { WithSchemaPlugin } from './plugin/with-schema/with-schema-plugin.js'
 import { DrainOuterGeneric } from './util/type-utils.js'
 
+// @ts-ignore
+Symbol.asyncDispose ??= Symbol('Symbol.asyncDispose')
+
 /**
  * The main Kysely class.
  *

test/node/src/async-dispose.test.ts

@@ -1,52 +1,65 @@
 import {
   CompiledQuery,
+  DatabaseConnection,
   DummyDriver,
   Kysely,
   PostgresAdapter,
   PostgresIntrospector,
   PostgresQueryCompiler,
+  QueryResult,
   RootOperationNode,
   sql,
 } from '../../..'
 import { expect } from './test-setup'
 
 describe('async dispose', function () {
-  it.only('should call destroy ', async () => {
-    const steps: string[] = [];
+  it('should call destroy ', async () => {
+    const steps: string[] = []
 
-    async function runScope() {
-        await using db = new Kysely({
-          dialect: {
-            createAdapter: () => new PostgresAdapter(),
-            createDriver: () => new (class SpiedOnDummyDriver extends DummyDriver {
-                async destroy(): Promise<void> {
-                    await new Promise((resolve) => setTimeout(resolve, 100))
-                    steps.push('destroyed')
-                }
+    {
+      await using db = new Kysely({
+        dialect: {
+          createAdapter: () => new PostgresAdapter(),
+          createDriver: () =>
+            new (class extends DummyDriver {
+              async acquireConnection() {
+                return new (class implements DatabaseConnection {
+                  async executeQuery<R>(): Promise<QueryResult<R>> {
+                    steps.push('executed')
+                    return { rows: [] }
+                  }
+                  streamQuery<R>(): AsyncIterableIterator<QueryResult<R>> {
+                    throw new Error('Method not implemented.')
+                  }
+                })()
+              }
+              async destroy(): Promise<void> {
+                steps.push('destroyed')
+              }
             })(),
-            createIntrospector: (db) => new PostgresIntrospector(db),
-            createQueryCompiler: () => new (class SpiedOnPostgresQueryCompiler extends PostgresQueryCompiler {
-                compileQuery(node: RootOperationNode): CompiledQuery<unknown> {
-                    const compiled = super.compileQuery(node)
-                    steps.push('compiled')
-                    return compiled
-                }
+          createIntrospector: (db) => new PostgresIntrospector(db),
+          createQueryCompiler: () =>
+            new (class extends PostgresQueryCompiler {
+              compileQuery(node: RootOperationNode): CompiledQuery<unknown> {
+                const compiled = super.compileQuery(node)
+                steps.push('compiled')
+                return compiled
+              }
             })(),
-          },
-        })
+        },
+      })
 
-        sql`select 1`.compile(db);
+      await sql`select 1`.execute(db)
     }
 
-    await runScope()
-
     steps.push('after runScope')
 
     expect(steps).to.length.to.be.greaterThan(1)
     expect(steps).to.deep.equal([
-        'compiled',
-        'destroyed',
-        'after runScope',
+      'compiled',
+      'executed',
+      'destroyed',
+      'after runScope',
     ])
   })
 })

tsconfig-base.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "moduleResolution": "Node",
-    "target": "ESNext",
+    "target": "ES2022",
     "lib": ["ESNext"],
     "declaration": true,
     "strict": true,