@onreza/prisma-adapter-bun 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ONREZA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,206 @@
+# @onreza/prisma-adapter-bun
+
+Prisma 7+ driver adapter for [Bun.sql](https://bun.com/docs/api/sql) — use Bun's built-in PostgreSQL client instead of `pg`.
+
+- Zero external database dependencies — uses Bun's native PostgreSQL bindings
+- Full Prisma compatibility — CRUD, relations, transactions, migrations, raw queries, TypedSQL
+- Type-safe — ships as TypeScript source, ready to use with Bun
+
+## Installation
+
+```bash
+bun add @onreza/prisma-adapter-bun @prisma/driver-adapter-utils
+```
+
+## Quick Start
+
+### 1. Prisma Schema
+
+```prisma
+// prisma/schema.prisma
+datasource db {
+  provider = "postgresql"
+}
+
+generator client {
+  provider = "prisma-client"
+  output   = "./generated"
+}
+
+model User {
+  id    Int    @id @default(autoincrement())
+  email String @unique
+  name  String?
+}
+```
+
+### 2. Prisma Config (for migrations)
+
+```ts
+// prisma.config.ts
+import { defineConfig } from "prisma/config";
+
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  datasource: {
+    url: process.env.DATABASE_URL!,
+  },
+});
+```
+
+### 3. Generate & Migrate
+
+```bash
+bunx prisma generate
+DATABASE_URL="postgres://user:pass@localhost:5432/mydb" bunx prisma db push
+```
+
+### 4. Use
+
+```ts
+import { PrismaClient } from "./prisma/generated/client";
+import { PrismaBun } from "@onreza/prisma-adapter-bun";
+
+const adapter = new PrismaBun("postgres://user:pass@localhost:5432/mydb");
+const prisma = new PrismaClient({ adapter });
+
+const users = await prisma.user.findMany();
+console.log(users);
+```
+
+## Configuration
+
+### Connection String
+
+```ts
+const adapter = new PrismaBun("postgres://user:pass@localhost:5432/mydb");
+```
+
+### Connection Options
+
+```ts
+import { SQL } from "bun";
+
+const adapter = new PrismaBun({
+  hostname: "localhost",
+  port: 5432,
+  database: "mydb",
+  username: "user",
+  password: "pass",
+  tls: true,
+} satisfies SQL.PostgresOrMySQLOptions);
+```
+
+### Existing Bun.sql Client
+
+```ts
+import { SQL } from "bun";
+
+const client = new SQL("postgres://user:pass@localhost:5432/mydb");
+const adapter = new PrismaBun(client);
+```
+
+### Schema Option
+
+```ts
+const adapter = new PrismaBun("postgres://...", { schema: "my_schema" });
+```
+
+## API
+
+### `PrismaBun` (factory)
+
+The main export. Implements Prisma's `SqlMigrationAwareDriverAdapterFactory`.
+
+```ts
+new PrismaBun(config: string | URL | SQL.PostgresOrMySQLOptions, options?: PrismaBunOptions)
+new PrismaBun(client: SQL, options?: PrismaBunOptions)
+```
+
+**Options:**
+
+| Option   | Type     | Default    | Description             |
+|----------|----------|------------|-------------------------|
+| `schema` | `string` | `"public"` | PostgreSQL search path  |
+
+**Methods:**
+
+| Method              | Description                                         |
+|---------------------|-----------------------------------------------------|
+| `connect()`         | Creates a new connection and returns an adapter      |
+| `connectToShadowDb()` | Creates a temporary database for Prisma Migrate   |
+
+### `PrismaBunAdapter`
+
+Low-level adapter for direct use (without factory). Implements `SqlDriverAdapter`.
+
+```ts
+import { SQL } from "bun";
+import { PrismaBunAdapter } from "@onreza/prisma-adapter-bun";
+
+const client = new SQL("postgres://...");
+const adapter = new PrismaBunAdapter(client);
+```
+
+## Supported Features
+
+| Feature                     | Status |
+|-----------------------------|--------|
+| CRUD (create, read, update, delete) | Supported |
+| Relations (1:1, 1:N, M:N)  | Supported |
+| Interactive transactions    | Supported |
+| Batch transactions          | Supported |
+| Isolation levels            | Supported |
+| `$queryRaw` / `$executeRaw`| Supported |
+| TypedSQL                    | Supported |
+| Prisma Migrate              | Supported |
+| Shadow database             | Supported |
+| All PostgreSQL scalar types | Supported |
+| Array types (`String[]`, etc.) | Supported |
+| Json / Bytes / Decimal / BigInt | Supported |
+| Enums                       | Supported |
+| Connection pooling          | Built-in (Bun.sql) |
+
+## Requirements
+
+- **Bun** >= 1.2.0 (for `Bun.sql` support)
+- **PostgreSQL** >= 12
+- **Prisma** >= 7.0.0
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run unit tests (no database needed)
+bun test tests/conversion.test.ts tests/errors.test.ts
+
+# Run integration tests (needs PostgreSQL)
+DATABASE_URL="postgres://postgres:postgres@localhost:5432/postgres" bun test tests/adapter.test.ts
+
+# Run e2e tests (needs Docker)
+bun test --timeout 120000 tests/factory.test.ts tests/prisma.test.ts
+
+# Run all tests
+DATABASE_URL="postgres://postgres:postgres@localhost:5432/postgres" bun test --timeout 120000
+
+# Type check
+bunx tsc --noEmit
+```
+
+## How It Works
+
+This adapter bridges Prisma's driver adapter protocol with Bun's built-in `Bun.sql` PostgreSQL client:
+
+1. **Queries** — Prisma generates parameterized SQL (`$1`, `$2`, ...). The adapter passes them to `Bun.sql.unsafe(sql, values)`, which binds parameters at the PostgreSQL wire protocol level.
+
+2. **Type Mapping** — PostgreSQL column types are mapped to Prisma's `ColumnType` enum. Since Bun.sql doesn't yet expose column OID metadata, types are inferred from JavaScript values. When Bun adds `.columns` support, the adapter will automatically use native OIDs.
+
+3. **Transactions** — Uses `Bun.sql.reserve()` to get a dedicated connection, then sends `BEGIN`/`COMMIT`/`ROLLBACK` as Prisma expects.
+
+4. **Migrations** — The factory's `connectToShadowDb()` creates a temporary database for Prisma Migrate, and cleans it up on dispose.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@onreza/prisma-adapter-bun",
+  "version": "0.3.0",
+  "description": "Prisma 7+ driver adapter for Bun.sql — use Bun's built-in PostgreSQL client instead of pg",
+  "license": "MIT",
+  "type": "module",
+  "module": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "LICENSE",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ONREZA/prisma-adapter-bun.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ONREZA/prisma-adapter-bun/issues"
+  },
+  "homepage": "https://github.com/ONREZA/prisma-adapter-bun#readme",
+  "keywords": [
+    "prisma",
+    "bun",
+    "bun-sql",
+    "postgresql",
+    "postgres",
+    "driver-adapter",
+    "database",
+    "orm"
+  ],
+  "engines": {
+    "bun": ">=1.2.0"
+  },
+  "dependencies": {
+    "@prisma/driver-adapter-utils": "^7.3.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.14",
+    "@commitlint/types": "^20.4.0",
+    "@prisma/client": "^7.3.0",
+    "@types/bun": "latest",
+    "lefthook": "^2.1.0",
+    "onreza-release": "^2.3.0",
+    "prisma": "^7.3.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "scripts": {
+    "lint": "biome check",
+    "lint:fix": "biome check --write",
+    "format": "biome format --write",
+    "typecheck": "tsc --noEmit",
+    "check": "biome check && tsc --noEmit",
+    "test": "bun test tests/conversion.test.ts tests/errors.test.ts",
+    "test:integration": "bun test tests/adapter.test.ts",
+    "test:e2e": "bun test --timeout 120000 tests/factory.test.ts tests/prisma.test.ts",
+    "test:all": "bun test --timeout 120000",
+    "prepublishOnly": "bunx tsc --noEmit",
+    "release": "onreza-release",
+    "release:dry": "onreza-release --dry-run",
+    "prepare": "lefthook install || true"
+  }
+}

package/src/adapter.ts

@@ -0,0 +1,256 @@
+import {
+  type ColumnType,
+  type ConnectionInfo,
+  DriverAdapterError,
+  type IsolationLevel,
+  type SqlDriverAdapter,
+  type SqlQuery,
+  type SqlQueryable,
+  type SqlResultSet,
+  type Transaction,
+  type TransactionOptions,
+} from "@prisma/driver-adapter-utils";
+import type { SQL as BunSQL, ReservedSQL } from "bun";
+import {
+  fieldToColumnType,
+  findFirstNonNullInColumn,
+  inferOidFromValue,
+  mapArg,
+  resultNormalizers,
+  UnsupportedNativeDataType,
+} from "./conversion.ts";
+import { convertDriverError } from "./errors.ts";
+import type { ColumnMetadata, PrismaBunOptions } from "./types.ts";
+
+const ADAPTER_NAME = "@onreza/prisma-adapter-bun";
+
+const VALID_ISOLATION_LEVELS = new Set(["READ UNCOMMITTED", "READ COMMITTED", "REPEATABLE READ", "SERIALIZABLE"]);
+
+type QueryResult = {
+  columns: ColumnMetadata[];
+  rows: unknown[][];
+  rowCount: number;
+};
+
+class BunQueryable implements SqlQueryable {
+  readonly provider = "postgres" as const;
+  readonly adapterName = ADAPTER_NAME;
+
+  constructor(
+    protected readonly client: BunSQL | ReservedSQL,
+    protected readonly bunOptions?: PrismaBunOptions,
+  ) {}
+
+  protected async performIO(query: SqlQuery): Promise<QueryResult> {
+    const { sql, args, argTypes } = query;
+    const values = args.map((arg, i) => {
+      const argType = argTypes[i];
+      if (!argType) return arg;
+      return mapArg(arg, argType);
+    });
+
+    try {
+      // Execute query in regular (object) mode
+      const result = await this.client.unsafe(sql, values);
+      const resultRecord = result as unknown as Record<string, unknown>;
+      const rowCount: number = (resultRecord.count as number) ?? result.length;
+
+      // Primary path: use .columns metadata if Bun.sql exposes it
+      const rawColumns = resultRecord.columns;
+      if (Array.isArray(rawColumns) && rawColumns.length > 0) {
+        const columns: ColumnMetadata[] = rawColumns.map((c: Record<string, unknown>) => ({
+          name: String(c.name),
+          type: Number(c.type),
+        }));
+        // Convert object rows to array rows using column order from metadata
+        const objectRows = result as unknown as Record<string, unknown>[];
+        const rows: unknown[][] = objectRows.map((row) => columns.map((col) => row[col.name]));
+        return { columns, rowCount, rows };
+      }
+
+      // Fallback: extract column names from object keys, infer types from values
+      if (result.length === 0) {
+        return { columns: [], rowCount, rows: [] };
+      }
+
+      const firstRow = result[0] as Record<string, unknown>;
+      const columnNames = Object.keys(firstRow);
+
+      // Convert object rows to array rows
+      const objectRows = result as unknown as Record<string, unknown>[];
+      const rows: unknown[][] = objectRows.map((row) => columnNames.map((name) => row[name]));
+
+      // Infer OID for each column from first non-null value
+      const columns: ColumnMetadata[] = columnNames.map((name, i) => ({
+        name,
+        type: inferOidFromValue(findFirstNonNullInColumn(rows, i)),
+      }));
+
+      return { columns, rowCount, rows };
+    } catch (e) {
+      throw new DriverAdapterError(convertDriverError(e));
+    }
+  }
+
+  async queryRaw(query: SqlQuery): Promise<SqlResultSet> {
+    const { columns, rows } = await this.performIO(query);
+
+    const columnNames = columns.map((col) => col.name);
+    const columnTypes = this.mapColumnTypes(columns);
+    this.normalizeRows(columns, rows);
+
+    return { columnNames, columnTypes, rows };
+  }
+
+  private mapColumnTypes(columns: ColumnMetadata[]): ColumnType[] {
+    try {
+      return columns.map((col) => fieldToColumnType(col.type));
+    } catch (e) {
+      if (e instanceof UnsupportedNativeDataType) {
+        throw new DriverAdapterError({
+          kind: "UnsupportedNativeDataType",
+          type: e.type,
+        });
+      }
+      throw e;
+    }
+  }
+
+  private normalizeRows(columns: ColumnMetadata[], rows: unknown[][]): void {
+    for (let i = 0; i < columns.length; i++) {
+      const col = columns[i];
+      if (!col) continue;
+      const normalizer = resultNormalizers[col.type];
+      if (normalizer) {
+        for (const row of rows) {
+          if (row[i] !== null && row[i] !== undefined) {
+            row[i] = normalizer(row[i]);
+          }
+        }
+      }
+    }
+  }
+
+  async executeRaw(query: SqlQuery): Promise<number> {
+    const { rowCount } = await this.performIO(query);
+    return rowCount;
+  }
+}
+
+export class BunTransaction extends BunQueryable implements Transaction {
+  readonly txOptions: TransactionOptions = { usePhantomQuery: false };
+  private released = false;
+
+  constructor(
+    protected override readonly client: ReservedSQL,
+    bunOptions?: PrismaBunOptions,
+  ) {
+    super(client, bunOptions);
+  }
+
+  get options(): TransactionOptions {
+    return this.txOptions;
+  }
+
+  private release(): void {
+    if (!this.released) {
+      this.released = true;
+      this.client.release();
+    }
+  }
+
+  commit(): Promise<void> {
+    // Prisma Engine sends COMMIT via executeRaw before calling commit().
+    // We only release the reserved connection back to the pool.
+    this.release();
+    return Promise.resolve();
+  }
+
+  rollback(): Promise<void> {
+    // Prisma Engine sends ROLLBACK via executeRaw before calling rollback().
+    // We only release the reserved connection.
+    this.release();
+    return Promise.resolve();
+  }
+}
+
+export class PrismaBunAdapter extends BunQueryable implements SqlDriverAdapter {
+  private readonly disposeCallback?: () => Promise<void>;
+
+  constructor(
+    protected override readonly client: BunSQL,
+    bunOptions?: PrismaBunOptions,
+    disposeCallback?: () => Promise<void>,
+  ) {
+    super(client, bunOptions);
+    this.disposeCallback = disposeCallback;
+  }
+
+  async startTransaction(isolationLevel?: IsolationLevel): Promise<Transaction> {
+    if (isolationLevel && !VALID_ISOLATION_LEVELS.has(isolationLevel.toUpperCase())) {
+      throw new DriverAdapterError({
+        code: "INVALID_ISOLATION_LEVEL",
+        column: undefined,
+        detail: undefined,
+        hint: undefined,
+        kind: "postgres",
+        message: `Invalid isolation level: ${isolationLevel}`,
+        severity: "ERROR",
+      });
+    }
+
+    const reserved = await this.client.reserve();
+
+    try {
+      const tx = new BunTransaction(reserved, this.bunOptions);
+
+      await tx.executeRaw({ args: [], argTypes: [], sql: "BEGIN" });
+
+      if (isolationLevel) {
+        await tx.executeRaw({
+          args: [],
+          argTypes: [],
+          sql: `SET TRANSACTION ISOLATION LEVEL ${isolationLevel.toUpperCase()}`,
+        });
+      }
+
+      return tx;
+    } catch (error) {
+      try {
+        await reserved.unsafe("ROLLBACK");
+      } catch {
+        // Ignore rollback errors during cleanup
+      }
+      reserved.release();
+      throw error;
+    }
+  }
+
+  async executeScript(script: string): Promise<void> {
+    try {
+      await this.client.unsafe(script).simple();
+    } catch (e) {
+      throw new DriverAdapterError(convertDriverError(e));
+    }
+  }
+
+  getConnectionInfo(): ConnectionInfo {
+    return {
+      maxBindValues: 65535,
+      schemaName: this.bunOptions?.schema ?? "public",
+      supportsRelationJoins: true,
+    };
+  }
+
+  async dispose(): Promise<void> {
+    try {
+      if (this.disposeCallback) {
+        await this.disposeCallback();
+      } else {
+        await this.client.close();
+      }
+    } catch (e) {
+      throw new DriverAdapterError(convertDriverError(e));
+    }
+  }
+}

package/src/conversion.ts

@@ -0,0 +1,388 @@
+import { type ArgType, type ColumnType, ColumnTypeEnum } from "@prisma/driver-adapter-utils";
+
+// Top-level regex constants (biome: useTopLevelRegex)
+const RE_TIMESTAMPTZ_OFFSET = /([+-]\d{2})$/;
+const RE_TIMETZ_STRIP = /[+-]\d{2}(:\d{2})?$/;
+const RE_MONEY_SYMBOL = /^\$/;
+const RE_PG_ESCAPE_BACKSLASH = /\\/g;
+const RE_PG_ESCAPE_QUOTE = /"/g;
+
+// PostgreSQL OIDs (from pg_type system catalog)
+export const PgOid = {
+  BIT: 1560,
+  BIT_ARRAY: 1561,
+  BOOL: 16,
+
+  // Array types
+  BOOL_ARRAY: 1000,
+  BPCHAR: 1042,
+  BPCHAR_ARRAY: 1014,
+  BYTEA: 17,
+  BYTEA_ARRAY: 1001,
+  CHAR: 18,
+  CHAR_ARRAY: 1002,
+  CIDR: 650,
+  CIDR_ARRAY: 651,
+  DATE: 1082,
+  DATE_ARRAY: 1182,
+  FLOAT4: 700,
+  FLOAT4_ARRAY: 1021,
+  FLOAT8: 701,
+  FLOAT8_ARRAY: 1022,
+  INET: 869,
+  INET_ARRAY: 1041,
+  INT2: 21,
+  INT2_ARRAY: 1005,
+  INT4: 23,
+  INT4_ARRAY: 1007,
+  INT8: 20,
+  INT8_ARRAY: 1016,
+  JSON: 114,
+  JSON_ARRAY: 199,
+  JSONB: 3802,
+  JSONB_ARRAY: 3807,
+  MONEY: 790,
+  MONEY_ARRAY: 791,
+  NAME: 19,
+  NAME_ARRAY: 1003,
+  NUMERIC: 1700,
+  NUMERIC_ARRAY: 1231,
+  OID: 26,
+  OID_ARRAY: 1028,
+  TEXT: 25,
+  TEXT_ARRAY: 1009,
+  TIME: 1083,
+  TIME_ARRAY: 1183,
+  TIMESTAMP: 1114,
+  TIMESTAMP_ARRAY: 1115,
+  TIMESTAMPTZ: 1184,
+  TIMESTAMPTZ_ARRAY: 1185,
+  TIMETZ: 1266,
+  TIMETZ_ARRAY: 1270,
+  UUID: 2950,
+  UUID_ARRAY: 2951,
+  VARBIT: 1562,
+  VARBIT_ARRAY: 1563,
+  VARCHAR: 1043,
+  VARCHAR_ARRAY: 1015,
+  XML: 142,
+  XML_ARRAY: 143,
+} as const;
+
+// OID threshold: types >= this are user-defined (enums, composites, etc.)
+const FIRST_NORMAL_OBJECT_ID = 16384;
+
+export class UnsupportedNativeDataType extends Error {
+  type: string;
+  constructor(oid: number) {
+    const message = `Unsupported column type with OID ${oid}`;
+    super(message);
+    this.type = `${oid}`;
+  }
+}
+
+const scalarMapping: Record<number, ColumnType> = {
+  [PgOid.INT2]: ColumnTypeEnum.Int32,
+  [PgOid.INT4]: ColumnTypeEnum.Int32,
+  [PgOid.INT8]: ColumnTypeEnum.Int64,
+  [PgOid.FLOAT4]: ColumnTypeEnum.Float,
+  [PgOid.FLOAT8]: ColumnTypeEnum.Double,
+  [PgOid.BOOL]: ColumnTypeEnum.Boolean,
+  [PgOid.DATE]: ColumnTypeEnum.Date,
+  [PgOid.TIME]: ColumnTypeEnum.Time,
+  [PgOid.TIMETZ]: ColumnTypeEnum.Time,
+  [PgOid.TIMESTAMP]: ColumnTypeEnum.DateTime,
+  [PgOid.TIMESTAMPTZ]: ColumnTypeEnum.DateTime,
+  [PgOid.NUMERIC]: ColumnTypeEnum.Numeric,
+  [PgOid.MONEY]: ColumnTypeEnum.Numeric,
+  [PgOid.JSON]: ColumnTypeEnum.Json,
+  [PgOid.JSONB]: ColumnTypeEnum.Json,
+  [PgOid.UUID]: ColumnTypeEnum.Uuid,
+  [PgOid.OID]: ColumnTypeEnum.Int64,
+  [PgOid.BPCHAR]: ColumnTypeEnum.Text,
+  [PgOid.TEXT]: ColumnTypeEnum.Text,
+  [PgOid.VARCHAR]: ColumnTypeEnum.Text,
+  [PgOid.BIT]: ColumnTypeEnum.Text,
+  [PgOid.VARBIT]: ColumnTypeEnum.Text,
+  [PgOid.INET]: ColumnTypeEnum.Text,
+  [PgOid.CIDR]: ColumnTypeEnum.Text,
+  [PgOid.XML]: ColumnTypeEnum.Text,
+  [PgOid.NAME]: ColumnTypeEnum.Text,
+  [PgOid.CHAR]: ColumnTypeEnum.Character,
+  [PgOid.BYTEA]: ColumnTypeEnum.Bytes,
+};
+
+const arrayMapping: Record<number, ColumnType> = {
+  [PgOid.INT2_ARRAY]: ColumnTypeEnum.Int32Array,
+  [PgOid.INT4_ARRAY]: ColumnTypeEnum.Int32Array,
+  [PgOid.INT8_ARRAY]: ColumnTypeEnum.Int64Array,
+  [PgOid.FLOAT4_ARRAY]: ColumnTypeEnum.FloatArray,
+  [PgOid.FLOAT8_ARRAY]: ColumnTypeEnum.DoubleArray,
+  [PgOid.BOOL_ARRAY]: ColumnTypeEnum.BooleanArray,
+  [PgOid.DATE_ARRAY]: ColumnTypeEnum.DateArray,
+  [PgOid.TIME_ARRAY]: ColumnTypeEnum.TimeArray,
+  [PgOid.TIMETZ_ARRAY]: ColumnTypeEnum.TimeArray,
+  [PgOid.TIMESTAMP_ARRAY]: ColumnTypeEnum.DateTimeArray,
+  [PgOid.TIMESTAMPTZ_ARRAY]: ColumnTypeEnum.DateTimeArray,
+  [PgOid.NUMERIC_ARRAY]: ColumnTypeEnum.NumericArray,
+  [PgOid.MONEY_ARRAY]: ColumnTypeEnum.NumericArray,
+  [PgOid.JSON_ARRAY]: ColumnTypeEnum.JsonArray,
+  [PgOid.JSONB_ARRAY]: ColumnTypeEnum.JsonArray,
+  [PgOid.UUID_ARRAY]: ColumnTypeEnum.UuidArray,
+  [PgOid.OID_ARRAY]: ColumnTypeEnum.Int64Array,
+  [PgOid.BPCHAR_ARRAY]: ColumnTypeEnum.TextArray,
+  [PgOid.TEXT_ARRAY]: ColumnTypeEnum.TextArray,
+  [PgOid.VARCHAR_ARRAY]: ColumnTypeEnum.TextArray,
+  [PgOid.BIT_ARRAY]: ColumnTypeEnum.TextArray,
+  [PgOid.VARBIT_ARRAY]: ColumnTypeEnum.TextArray,
+  [PgOid.INET_ARRAY]: ColumnTypeEnum.TextArray,
+  [PgOid.CIDR_ARRAY]: ColumnTypeEnum.TextArray,
+  [PgOid.XML_ARRAY]: ColumnTypeEnum.TextArray,
+  [PgOid.NAME_ARRAY]: ColumnTypeEnum.TextArray,
+  [PgOid.CHAR_ARRAY]: ColumnTypeEnum.CharacterArray,
+  [PgOid.BYTEA_ARRAY]: ColumnTypeEnum.BytesArray,
+};
+
+export function fieldToColumnType(oid: number): ColumnType {
+  const scalar = scalarMapping[oid];
+  if (scalar !== undefined) return scalar;
+
+  const array = arrayMapping[oid];
+  if (array !== undefined) return array;
+
+  // User-defined types (enums, composites) are treated as Text
+  if (oid >= FIRST_NORMAL_OBJECT_ID) return ColumnTypeEnum.Text;
+
+  throw new UnsupportedNativeDataType(oid);
+}
+
+// --- Value normalizers (post-processing Bun.sql results) ---
+
+function pad2(n: number): string {
+  return n < 10 ? `0${n}` : `${n}`;
+}
+
+function pad3(n: number): string {
+  if (n < 10) return `00${n}`;
+  if (n < 100) return `0${n}`;
+  return `${n}`;
+}
+
+function formatDateTime(date: Date): string {
+  return (
+    `${date.getUTCFullYear()}-${pad2(date.getUTCMonth() + 1)}-${pad2(date.getUTCDate())} ` +
+    `${pad2(date.getUTCHours())}:${pad2(date.getUTCMinutes())}:${pad2(date.getUTCSeconds())}.${pad3(date.getUTCMilliseconds())}`
+  );
+}
+
+function formatDate(date: Date): string {
+  return `${date.getUTCFullYear()}-${pad2(date.getUTCMonth() + 1)}-${pad2(date.getUTCDate())}`;
+}
+
+function formatTime(date: Date): string {
+  return `${pad2(date.getUTCHours())}:${pad2(date.getUTCMinutes())}:${pad2(date.getUTCSeconds())}.${pad3(date.getUTCMilliseconds())}`;
+}
+
+// Normalize a timestamp string to ISO-like format: "2024-01-01 12:00:00" -> "2024-01-01T12:00:00.000+00:00"
+function normalizeTimestamp(value: unknown): unknown {
+  if (value instanceof Date) {
+    return `${formatDateTime(value)}+00:00`;
+  }
+  if (typeof value === "string") {
+    return `${value.replace(" ", "T")}+00:00`;
+  }
+  return value;
+}
+
+function normalizeTimestamptz(value: unknown): unknown {
+  if (value instanceof Date) {
+    return `${formatDateTime(value)}+00:00`;
+  }
+  if (typeof value === "string") {
+    // Normalize various timezone formats to +00:00
+    return value.replace(" ", "T").replace(RE_TIMESTAMPTZ_OFFSET, "$1:00");
+  }
+  return value;
+}
+
+function normalizeTimetz(value: unknown): unknown {
+  if (typeof value === "string") {
+    // Remove timezone offset from time value
+    return value.replace(RE_TIMETZ_STRIP, "");
+  }
+  return value;
+}
+
+function normalizeDate(value: unknown): unknown {
+  if (value instanceof Date) {
+    return formatDate(value);
+  }
+  return value;
+}
+
+function normalizeTime(value: unknown): unknown {
+  if (value instanceof Date) {
+    return formatTime(value);
+  }
+  return value;
+}
+
+function normalizeNumeric(value: unknown): unknown {
+  return String(value);
+}
+
+function normalizeMoney(value: unknown): unknown {
+  const s = String(value);
+  return s.replace(RE_MONEY_SYMBOL, "");
+}
+
+function normalizeJson(value: unknown): unknown {
+  if (typeof value === "object" && value !== null) {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+
+function normalizeBytes(value: unknown): unknown {
+  if (value instanceof Uint8Array || value instanceof Buffer) {
+    return Buffer.from(value);
+  }
+  return value;
+}
+
+function normalizeArray(value: unknown, elementNormalizer: (v: unknown) => unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((el) => (el === null ? null : elementNormalizer(el)));
+  }
+  return value;
+}
+
+type Normalizer = (value: unknown) => unknown;
+
+export const resultNormalizers: Record<number, Normalizer> = {
+  [PgOid.NUMERIC]: normalizeNumeric,
+  [PgOid.MONEY]: normalizeMoney,
+  [PgOid.TIME]: normalizeTime,
+  [PgOid.TIMETZ]: normalizeTimetz,
+  [PgOid.DATE]: normalizeDate,
+  [PgOid.TIMESTAMP]: normalizeTimestamp,
+  [PgOid.TIMESTAMPTZ]: normalizeTimestamptz,
+  [PgOid.JSON]: normalizeJson,
+  [PgOid.JSONB]: normalizeJson,
+  [PgOid.BYTEA]: normalizeBytes,
+
+  // Array normalizers
+  [PgOid.NUMERIC_ARRAY]: (v) => normalizeArray(v, normalizeNumeric),
+  [PgOid.MONEY_ARRAY]: (v) => normalizeArray(v, normalizeMoney),
+  [PgOid.TIME_ARRAY]: (v) => normalizeArray(v, normalizeTime),
+  [PgOid.TIMETZ_ARRAY]: (v) => normalizeArray(v, normalizeTimetz),
+  [PgOid.DATE_ARRAY]: (v) => normalizeArray(v, normalizeDate),
+  [PgOid.TIMESTAMP_ARRAY]: (v) => normalizeArray(v, normalizeTimestamp),
+  [PgOid.TIMESTAMPTZ_ARRAY]: (v) => normalizeArray(v, normalizeTimestamptz),
+  [PgOid.JSON_ARRAY]: (v) => normalizeArray(v, normalizeJson),
+  [PgOid.JSONB_ARRAY]: (v) => normalizeArray(v, normalizeJson),
+  [PgOid.BYTEA_ARRAY]: (v) => normalizeArray(v, normalizeBytes),
+  [PgOid.BIT_ARRAY]: (v) => normalizeArray(v, String),
+  [PgOid.VARBIT_ARRAY]: (v) => normalizeArray(v, String),
+  [PgOid.XML_ARRAY]: (v) => normalizeArray(v, String),
+};
+
+// --- Type inference (fallback when .columns metadata is unavailable) ---
+
+function inferArrayOid(arr: unknown[]): number {
+  if (arr.length === 0) return PgOid.TEXT_ARRAY;
+  const first = arr.find((v) => v !== null && v !== undefined);
+  if (first === undefined) return PgOid.TEXT_ARRAY;
+  if (typeof first === "number") {
+    return Number.isInteger(first) ? PgOid.INT8_ARRAY : PgOid.FLOAT8_ARRAY;
+  }
+  if (typeof first === "boolean") return PgOid.BOOL_ARRAY;
+  if (first instanceof Date) return PgOid.TIMESTAMPTZ_ARRAY;
+  if (typeof first === "object") return PgOid.JSONB_ARRAY;
+  return PgOid.TEXT_ARRAY;
+}
+
+/**
+ * Infer a PostgreSQL OID from a JavaScript value.
+ * Used as a fallback when Bun.sql doesn't expose column metadata.
+ * The inferred OID is then mapped to ColumnType via fieldToColumnType().
+ */
+export function inferOidFromValue(value: unknown): number {
+  if (value === null || value === undefined) return PgOid.TEXT;
+  if (typeof value === "boolean") return PgOid.BOOL;
+  if (typeof value === "bigint") return PgOid.INT8;
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? PgOid.INT8 : PgOid.FLOAT8;
+  }
+  if (value instanceof Date) return PgOid.TIMESTAMPTZ;
+  if (value instanceof Uint8Array || value instanceof Buffer) return PgOid.BYTEA;
+  if (Array.isArray(value)) return inferArrayOid(value);
+  if (typeof value === "object") return PgOid.JSONB;
+  return PgOid.TEXT;
+}
+
+/**
+ * Find the first non-null value for a given column across all rows.
+ */
+export function findFirstNonNullInColumn(rows: unknown[][], colIndex: number): unknown {
+  for (const row of rows) {
+    const val = row[colIndex];
+    if (val !== null && val !== undefined) return val;
+  }
+  return null;
+}
+
+// --- Array literal formatting (Bun.sql doesn't handle JS arrays in unsafe()) ---
+
+function escapePgArrayElement(value: unknown): string {
+  if (value === null || value === undefined) return "NULL";
+  if (typeof value === "boolean") return value ? "t" : "f";
+  if (typeof value === "number" || typeof value === "bigint") return String(value);
+  // Strings: escape backslashes and double-quotes, then wrap in quotes
+  const s = String(value);
+  return `"${s.replace(RE_PG_ESCAPE_BACKSLASH, "\\\\").replace(RE_PG_ESCAPE_QUOTE, '\\"')}"`;
+}
+
+/**
+ * Convert a JS array to a PostgreSQL array literal string.
+ * Bun.sql's `unsafe()` does not serialize JS arrays as PostgreSQL arrays,
+ * so we must pass them in `{elem1,elem2,...}` format.
+ */
+export function toPgArrayLiteral(arr: unknown[]): string {
+  return `{${arr.map(escapePgArrayElement).join(",")}}`;
+}
+
+// --- Argument mapping (input parameters) ---
+
+export function mapArg(arg: unknown, argType: ArgType): unknown {
+  if (arg === null || arg === undefined) return null;
+
+  if (Array.isArray(arg) && argType.arity === "list") {
+    const mapped = arg.map((v) => mapArg(v, { ...argType, arity: "scalar" }));
+    return toPgArrayLiteral(mapped);
+  }
+
+  const value = typeof arg === "string" && argType.scalarType === "datetime" ? new Date(arg) : arg;
+
+  if (value instanceof Date) {
+    switch (argType.dbType) {
+      case "TIME":
+      case "TIMETZ":
+        return formatTime(value);
+      case "DATE":
+        return formatDate(value);
+      default:
+        return formatDateTime(value);
+    }
+  }
+
+  if (typeof value === "string" && argType.scalarType === "bytes") {
+    return Buffer.from(value, "base64");
+  }
+
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+
+  return value;
+}

package/src/errors.ts

@@ -0,0 +1,175 @@
+import type { Error as AdapterError } from "@prisma/driver-adapter-utils";
+import { SQL } from "bun";
+
+const RE_CONSTRAINT_KEY = /Key \((.+?)\)=/;
+
+function extractConstraintFields(detail?: string): { fields: string[] } | undefined {
+  if (!detail) return;
+  // PostgreSQL detail format: "Key (field1, field2)=(value1, value2) already exists."
+  const match = detail.match(RE_CONSTRAINT_KEY);
+  if (match?.[1]) {
+    return { fields: match[1].split(",").map((s) => s.trim()) };
+  }
+  return;
+}
+
+/**
+ * Get the PostgreSQL error code from a Bun SQL.PostgresError.
+ * Bun.sql stores the PG error code in `errno` (e.g., "42P01"),
+ * while `code` contains Bun's internal error code (e.g., "ERR_POSTGRES_SERVER_ERROR").
+ */
+function getPgErrorCode(error: SQL.PostgresError): string {
+  return error.errno ?? error.code;
+}
+
+function mapPostgresError(error: SQL.PostgresError): AdapterError {
+  const pgCode = getPgErrorCode(error);
+  const base = {
+    originalCode: pgCode,
+    originalMessage: error.message,
+  };
+
+  switch (pgCode) {
+    // Value too long for type
+    case "22001":
+      return { ...base, column: error.column, kind: "LengthMismatch" };
+
+    // Numeric value out of range
+    case "22003":
+      return { ...base, cause: error.message, kind: "ValueOutOfRange" };
+
+    // Invalid text representation / invalid input syntax
+    case "22P02":
+      return { ...base, kind: "InvalidInputValue", message: error.message };
+
+    // Unique violation
+    case "23505": {
+      const constraint =
+        extractConstraintFields(error.detail) ?? (error.constraint ? { index: error.constraint } : undefined);
+      return { ...base, constraint, kind: "UniqueConstraintViolation" };
+    }
+
+    // Not null violation
+    case "23502": {
+      const constraint = error.column ? { fields: [error.column] } : undefined;
+      return { ...base, constraint, kind: "NullConstraintViolation" };
+    }
+
+    // Foreign key violation
+    case "23503": {
+      const constraint =
+        extractConstraintFields(error.detail) ?? (error.constraint ? { index: error.constraint } : undefined);
+      return { ...base, constraint, kind: "ForeignKeyConstraintViolation" };
+    }
+
+    // Database does not exist
+    case "3D000":
+      return { ...base, db: error.message, kind: "DatabaseDoesNotExist" };
+
+    // Database already exists
+    case "42P04":
+      return { ...base, db: error.message, kind: "DatabaseAlreadyExists" };
+
+    // Insufficient privilege / authorization
+    case "28000":
+      return { ...base, kind: "DatabaseAccessDenied" };
+
+    // Password authentication failed
+    case "28P01":
+      return { ...base, kind: "AuthenticationFailed" };
+
+    // Serialization failure (transaction conflict)
+    case "40001":
+      return { ...base, kind: "TransactionWriteConflict" };
+
+    // Undefined table
+    case "42P01":
+      return { ...base, kind: "TableDoesNotExist", table: error.table };
+
+    // Undefined column
+    case "42703":
+      return { ...base, column: error.column, kind: "ColumnNotFound" };
+
+    // Too many connections
+    case "53300":
+      return { ...base, cause: error.message, kind: "TooManyConnections" };
+
+    // Default: pass through as raw PostgreSQL error
+    default:
+      return {
+        ...base,
+        code: pgCode,
+        column: error.column,
+        detail: error.detail,
+        hint: error.hint,
+        kind: "postgres",
+        message: error.message,
+        severity: error.severity ?? "ERROR",
+      };
+  }
+}
+
+function mapConnectionError(error: Error & { code?: string }): AdapterError {
+  const code = error.code ?? "";
+  const base = { originalCode: code, originalMessage: error.message };
+
+  if (code.includes("CONNECTION_CLOSED") || code === "ECONNRESET") {
+    return { ...base, kind: "ConnectionClosed" };
+  }
+
+  if (
+    code.includes("CONNECTION_TIMEOUT") ||
+    code === "ETIMEDOUT" ||
+    code.includes("IDLE_TIMEOUT") ||
+    code.includes("LIFETIME_TIMEOUT")
+  ) {
+    return { ...base, kind: "SocketTimeout" };
+  }
+
+  if (code.includes("TLS") || code.includes("SSL")) {
+    return { ...base, kind: "TlsConnectionError", reason: error.message };
+  }
+
+  if (code.includes("AUTHENTICATION_FAILED")) {
+    return { ...base, kind: "AuthenticationFailed" };
+  }
+
+  if (code === "ENOTFOUND" || code === "ECONNREFUSED") {
+    return { ...base, kind: "DatabaseNotReachable" };
+  }
+
+  return {
+    ...base,
+    code,
+    column: undefined,
+    detail: undefined,
+    hint: undefined,
+    kind: "postgres",
+    message: error.message,
+    severity: "ERROR",
+  };
+}
+
+export function convertDriverError(error: unknown): AdapterError {
+  if (error instanceof SQL.PostgresError) {
+    return mapPostgresError(error);
+  }
+
+  if (error instanceof SQL.SQLError) {
+    return mapConnectionError(error as Error & { code?: string });
+  }
+
+  if (error instanceof Error) {
+    return mapConnectionError(error as Error & { code?: string });
+  }
+
+  return {
+    code: "UNKNOWN",
+    column: undefined,
+    detail: undefined,
+    hint: undefined,
+    kind: "postgres",
+    message: String(error),
+    severity: "ERROR",
+  };
+}

package/src/factory.ts

@@ -0,0 +1,104 @@
+import type { SqlDriverAdapter, SqlMigrationAwareDriverAdapterFactory } from "@prisma/driver-adapter-utils";
+import { SQL } from "bun";
+import { PrismaBunAdapter } from "./adapter.ts";
+import type { BunSqlConfig, PrismaBunOptions } from "./types.ts";
+
+const ADAPTER_NAME = "@onreza/prisma-adapter-bun";
+
+/**
+ * Detect a Bun SQL client instance via duck-typing.
+ * `instanceof SQL` doesn't work because SQL.prototype is undefined in Bun.
+ */
+function isSqlClient(value: unknown): value is SQL {
+  const v = value as Record<string, unknown>;
+  return (
+    typeof value === "function" &&
+    typeof v.unsafe === "function" &&
+    typeof v.reserve === "function" &&
+    typeof v.close === "function"
+  );
+}
+
+export class PrismaBunFactory implements SqlMigrationAwareDriverAdapterFactory {
+  readonly provider = "postgres" as const;
+  readonly adapterName = ADAPTER_NAME;
+
+  private readonly config: BunSqlConfig;
+  private readonly bunOptions?: PrismaBunOptions;
+  private externalClient: SQL | null = null;
+
+  constructor(config: BunSqlConfig, options?: PrismaBunOptions);
+  constructor(client: SQL, options?: PrismaBunOptions);
+  constructor(configOrClient: BunSqlConfig | SQL, options?: PrismaBunOptions) {
+    this.bunOptions = options;
+    if (isSqlClient(configOrClient)) {
+      this.externalClient = configOrClient;
+      this.config = {};
+    } else {
+      this.config = configOrClient;
+    }
+  }
+
+  connect(): Promise<SqlDriverAdapter> {
+    if (this.externalClient) {
+      return Promise.resolve(new PrismaBunAdapter(this.externalClient, this.bunOptions, () => Promise.resolve()));
+    }
+
+    const client = new SQL(this.config as SQL.Options);
+
+    return Promise.resolve(
+      new PrismaBunAdapter(client, this.bunOptions, async () => {
+        await client.close();
+      }),
+    );
+  }
+
+  async connectToShadowDb(): Promise<SqlDriverAdapter> {
+    const mainAdapter = await this.connect();
+    const database = `prisma_migrate_shadow_db_${crypto.randomUUID()}`;
+
+    await mainAdapter.executeScript(`CREATE DATABASE "${database}"`);
+
+    let shadowClient: SQL;
+    try {
+      const shadowConfig = this.buildShadowConfig(database);
+      shadowClient = new SQL(shadowConfig as SQL.Options);
+    } catch (error) {
+      try {
+        await mainAdapter.executeScript(`DROP DATABASE IF EXISTS "${database}"`);
+      } finally {
+        await mainAdapter.dispose();
+      }
+      throw error;
+    }
+
+    return new PrismaBunAdapter(shadowClient, this.bunOptions, async () => {
+      await shadowClient.close();
+      try {
+        await mainAdapter.executeScript(`DROP DATABASE IF EXISTS "${database}"`);
+      } finally {
+        await mainAdapter.dispose();
+      }
+    });
+  }
+
+  private buildShadowConfig(database: string): SQL.PostgresOrMySQLOptions {
+    if (typeof this.config === "string" || this.config instanceof URL) {
+      const url = new URL(this.config.toString());
+      url.pathname = `/${database}`;
+      return { url: url.toString() };
+    }
+
+    if (typeof this.config === "object" && this.config !== null) {
+      const opts = this.config as SQL.PostgresOrMySQLOptions;
+      if (opts.url) {
+        const url = new URL(opts.url.toString());
+        url.pathname = `/${database}`;
+        return { ...opts, url: url.toString() };
+      }
+      return { ...opts, database };
+    }
+
+    return { database };
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { PrismaBunAdapter } from "./adapter.ts";
+export { PrismaBunFactory as PrismaBun } from "./factory.ts";
+export type { BunSqlConfig, PrismaBunOptions } from "./types.ts";

package/src/types.ts

@@ -0,0 +1,12 @@
+import type { SQL } from "bun";
+
+export type PrismaBunOptions = {
+  schema?: string;
+};
+
+export type BunSqlConfig = string | URL | SQL.PostgresOrMySQLOptions;
+
+export type ColumnMetadata = {
+  name: string;
+  type: number;
+};