@vibeorm/adapter-bun 1.0.2 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeorm/adapter-bun",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "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.0"
   },
   "publishConfig": {
     "access": "public"

package/src/index.ts

@@ -6,7 +6,8 @@
  * tagged templates.
  */
 
-import type { DatabaseAdapter, QueryResult } from "@vibeorm/runtime";
+import type { DatabaseAdapter, QueryResult, TransactionOptions } from "@vibeorm/runtime";
+import { normalizeError } from "@vibeorm/runtime";
 
 export type BunAdapterOptions = {
   /** PostgreSQL connection URL. Falls back to DATABASE_URL env var if not provided. */
@@ -73,6 +74,7 @@ export type BunAdapterOptions = {
 
 type SqlReserved = {
   (strings: TemplateStringsArray, ...values: unknown[]): Promise<unknown[]>;
+  unsafe(query: string, values?: unknown[]): Promise<unknown[]>;
   release(): void;
 };
 
@@ -228,34 +230,80 @@ 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) {
-        return executeQuery(sql, params);
+        try {
+          return await executeQuery(sql, params);
+        } catch (err) {
+          throw normalizeError({ error: err });
+        }
       },
 
       async executeUnsafe(params) {
-        const result = await sql.unsafe(params.text, params.values);
-        const resultAny = result as unknown as Record<string, unknown>;
-        let affectedRows: number;
-        if (typeof resultAny.count === "number") {
-          affectedRows = resultAny.count;
-        } else if (typeof resultAny.affectedRows === "number") {
-          affectedRows = resultAny.affectedRows;
-        } else {
-          affectedRows = (result as unknown[]).length;
+        try {
+          const result = await sql.unsafe(params.text, params.values);
+          const resultAny = result as unknown as Record<string, unknown>;
+          let affectedRows: number;
+          if (typeof resultAny.count === "number") {
+            affectedRows = resultAny.count;
+          } else if (typeof resultAny.affectedRows === "number") {
+            affectedRows = resultAny.affectedRows;
+          } else {
+            affectedRows = (result as unknown[]).length;
+          }
+          return {
+            rows: result as Record<string, unknown>[],
+            affectedRows,
+          };
+        } catch (err) {
+          throw normalizeError({ error: err });
         }
-        return {
-          rows: result as Record<string, unknown>[],
-          affectedRows,
-        };
       },
 
-      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) {
+          try {
+            return await sql.begin(async (txSql: SqlInstance) => {
+              const txAdapter = createAdapter(txSql);
+              return fn(txAdapter);
+            });
+          } catch (err) {
+            throw normalizeError({ error: err });
+          }
+        }
+
+        // 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 normalizeError({ error: err });
+        } finally {
+          reserved.release();
+        }
       },
 
       async connect() {
@@ -284,8 +332,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() {