Interim

src/core/Database.ts

@@ -37,6 +37,20 @@ export class Database<Meta extends QueryMeta = Either>
     return this.close()
   }
 
+  transact<T>(
+    gen: (tx: Transaction<Meta>) => Generator<Promise<unknown>, T>,
+    options?: TransactionOptions[Meta['dialect']]
+  ): Promise<T> {
+    return (<Database<any>>this).transaction(async (tx: Transaction<Meta>) => {
+      const iter = gen(tx)
+      let current: IteratorResult<Promise<unknown>>
+      while ((current = iter.next(tx))) {
+        if (current.done) return current.value
+        await current.value
+      }
+    }, options)
+  }
+
   transaction<T>(
     this: Database<Sync>,
     run: (tx: Transaction<Meta>) => T,

src/core/Query.ts

@@ -1,12 +1,12 @@
 import {
-  type HasTarget,
   getData,
   getResolver,
   hasResolver,
   internalData,
   internalQuery,
   type HasQuery,
-  type HasResolver
+  type HasResolver,
+  type HasTarget
 } from './Internal.ts'
 import type {Async, QueryMeta, Sync} from './MetaData.ts'
 import type {PreparedStatement, Resolver} from './Resolver.ts'
@@ -46,6 +46,15 @@ export abstract class Query<Result, Meta extends QueryMeta>
     }
   }
 
+  *[Symbol.iterator](): Generator<Promise<unknown>, Array<Result>, unknown> {
+    const interim = this.#exec('all')
+    const isAsync = interim instanceof Promise
+    if (!isAsync) return interim as Array<Result>
+    let result: unknown
+    yield interim.then(v => (result = v))
+    return result as Array<Result>
+  }
+
   prepare<Inputs extends Record<string, unknown>>(name: string) {
     return <PreparedQuery<Result, Inputs, Meta>>(
       getData(this).resolver!.prepare(this, name)

test/TestDriver.ts

@@ -220,6 +220,21 @@ export async function testDriver(
       }
     })
 
+    Test.it('universal transactions', async () => {
+      const result = await db.transact(function* (tx) {
+        yield* tx.createTable(Node)
+        yield* tx.insert(Node).values({
+          textField: 'hello',
+          bool: true
+        })
+        const nodes = yield* tx.select().from(Node)
+        Assert.isEqual(nodes, [{id: 1, textField: 'hello', bool: true}])
+        yield* tx.dropTable(Node)
+        return 1
+      })
+      Assert.isEqual(result, 1)
+    })
+
     Test.it('constraints and indexes', async () => {
       try {
         await db.createTable(TableA)

tsconfig.build.json

@@ -1,10 +1,4 @@
 {
   "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "declaration": true,
-    "emitDeclarationOnly": true,
-    "noEmit": false
-  },
   "include": ["src"]
 }