@vibeorm/adapter-bun 1.0.2 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeorm/adapter-bun",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "description": "Bun-native database adapter for VibeORM using bun:sql",
   "license": "MIT",
   "keywords": [
@@ -33,7 +33,7 @@
     "bun": ">=1.1.0"
   },
   "dependencies": {
-    "@vibeorm/runtime": "1.0.2"
+    "@vibeorm/runtime": "1.1.1"
   },
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -6,7 +6,7 @@
  * tagged templates.
  */
 
-import type { DatabaseAdapter, QueryResult } from "@vibeorm/runtime";
+import type { DatabaseAdapter, QueryResult, TransactionOptions } from "@vibeorm/runtime";
 
 export type BunAdapterOptions = {
   /** PostgreSQL connection URL. Falls back to DATABASE_URL env var if not provided. */
@@ -73,6 +73,7 @@ export type BunAdapterOptions = {
 
 type SqlReserved = {
   (strings: TemplateStringsArray, ...values: unknown[]): Promise<unknown[]>;
+  unsafe(query: string, values?: unknown[]): Promise<unknown[]>;
   release(): void;
 };
 
@@ -228,6 +229,14 @@ export function bunAdapter(options?: BunAdapterOptions): DatabaseAdapter {
     return result as Record<string, unknown>[];
   }
 
+  function isolationLevelToSql(params: { level: NonNullable<TransactionOptions["isolationLevel"]> }): string {
+    switch (params.level) {
+      case "ReadCommitted": return "READ COMMITTED";
+      case "RepeatableRead": return "REPEATABLE READ";
+      case "Serializable": return "SERIALIZABLE";
+    }
+  }
+
   function createAdapter(sql: SqlInstance): DatabaseAdapter {
     return {
       async execute(params) {
@@ -251,11 +260,37 @@ export function bunAdapter(options?: BunAdapterOptions): DatabaseAdapter {
         };
       },
 
-      async transaction<T>(fn: (txAdapter: DatabaseAdapter) => Promise<T>): Promise<T> {
-        return sql.begin(async (txSql: SqlInstance) => {
-          const txAdapter = createAdapter(txSql);
-          return fn(txAdapter);
-        });
+      async transaction<T>(fn: (txAdapter: DatabaseAdapter) => Promise<T>, options?: TransactionOptions): Promise<T> {
+        // Fast path: no custom options — use native sql.begin() for best performance
+        if (!options?.isolationLevel && !options?.timeout) {
+          return sql.begin(async (txSql: SqlInstance) => {
+            const txAdapter = createAdapter(txSql);
+            return fn(txAdapter);
+          });
+        }
+
+        // Manual path: reserve a connection for custom BEGIN options
+        const reserved = await sql.reserve();
+        try {
+          const isolation = options?.isolationLevel
+            ? ` ISOLATION LEVEL ${isolationLevelToSql({ level: options.isolationLevel })}`
+            : "";
+          await reserved.unsafe(`BEGIN${isolation}`);
+
+          if (options?.timeout) {
+            await reserved.unsafe(`SET LOCAL statement_timeout = ${Number(options.timeout)}`);
+          }
+
+          const txAdapter = createAdapter(reserved as unknown as SqlInstance);
+          const result = await fn(txAdapter);
+          await reserved.unsafe("COMMIT");
+          return result;
+        } catch (err) {
+          try { await reserved.unsafe("ROLLBACK"); } catch { /* rollback best-effort */ }
+          throw err;
+        } finally {
+          reserved.release();
+        }
       },
 
       async connect() {
@@ -284,8 +319,8 @@ export function bunAdapter(options?: BunAdapterOptions): DatabaseAdapter {
       return createAdapter(getSql()).executeUnsafe(params);
     },
 
-    async transaction<T>(fn: (txAdapter: DatabaseAdapter) => Promise<T>): Promise<T> {
-      return createAdapter(getSql()).transaction(fn);
+    async transaction<T>(fn: (txAdapter: DatabaseAdapter) => Promise<T>, options?: TransactionOptions): Promise<T> {
+      return createAdapter(getSql()).transaction(fn, options);
     },
 
     async connect() {