@vibeorm/adapter-mysql 2.0.0-alpha.1

package/README.md

@@ -0,0 +1,104 @@
+# @vibeorm/adapter-mysql
+
+> Part of **[VibeORM](https://github.com/vibeorm/vibeorm)** — a type-safe TypeScript ORM for Bun and Node. Prisma-schema or TypeScript-DSL input, a canonical schema IR, a generated client, and a dialect-aware SQL layer over PostgreSQL, PGlite, SQLite and MySQL.
+
+MySQL adapter built on [mysql2](https://github.com/sidorares/node-mysql2) (`mysql2/promise`), which ships as a direct dependency. It implements the frozen `DatabaseAdapter` contract from `@vibeorm/runtime` and runs on both Bun and Node.
+
+```bash
+bun add @vibeorm/adapter-mysql@alpha
+```
+
+> **Pre-release.** `2.0.0-alpha.x`, published under the `alpha` dist-tag. `npm i vibeorm` still resolves to the stable v1 line.
+
+## Usage
+
+```ts
+import { VibeClient } from "./generated/vibeorm/index.js";
+import { mysqlAdapter } from "@vibeorm/adapter-mysql";
+
+const db = VibeClient({ adapter: mysqlAdapter() }); // reads MYSQL_URL
+
+const users = await db.user.findMany({ where: { email: { contains: "@example.com" } }, take: 10 });
+
+await db.$disconnect();
+```
+
+## Options
+
+`mysqlAdapter(options?: MysqlAdapterOptions)`
+
+| Option | Type | Default | Meaning |
+|---|---|---|---|
+| `url` | `string` | `process.env.MYSQL_URL` | Connection URL, `mysql://user:pw@host:3306/db`. |
+| `host` / `port` / `user` / `password` / `database` | `string` / `number` | — | Discrete connection fields. When both are given, these win over the parsed `url`. |
+| `pool` | `MysqlPoolLike` | — | An existing mysql2 promise pool. The adapter never ends a pool it did not create, so `disconnect()` is a no-op; configuring it to the codec contract is on you. |
+| `connectionLimit` | `number` | mysql2's `10` | Maximum pooled connections. Ignored when `pool` is given. |
+| `timezone` | `string` | `"Z"` | mysql2 timezone. `DATETIME(3)` carries no zone, so `"Z"` makes outgoing `Date`s serialize as UTC and incoming text parse as UTC. mysql2's own default (`"local"`) would shift values by the process offset. |
+| `charset` | `string` | mysql2's `utf8mb4_general_ci` | Connection charset/collation. |
+| `multipleStatements` | `boolean` | `false` | Allow several statements per `executeUnsafe` call. Leave it off: the ORM never batches, `@vibeorm/migrate` applies DDL per statement, and it widens the injection blast radius of raw queries. |
+| `createPool` | `(config: MysqlPoolConfig) => MysqlPoolLike` | mysql2's `createPool` | Pool factory; a test seam. Ignored when `pool` is given. |
+
+The rest of the pool config is pinned to the runtime's `MYSQL_CODECS` contract and is not overridable: `decimalNumbers: false` and `supportBigNumbers` + `bigNumberStrings` (DECIMAL and BIGINT arrive as exact strings), `dateStrings: false` (DATETIME arrives as `Date`), `jsonStrings: false` (JSON arrives parsed), `namedPlaceholders: false` (the dialect renders positional `?`).
+
+`execute` (the ORM hot path) uses mysql2's binary protocol with per-connection prepared-statement caching; `executeUnsafe` (raw SQL and DDL) uses the text protocol, which is what makes DDL work.
+
+## Runtime support
+
+Node.js and Bun. mysql2 is a pure-JS driver and the dist output is plain ESM; the package declares `engines.bun >= 1.2.0` and is exercised on both runtimes.
+
+## Capabilities and limits
+
+The mysql capability table is frozen and mirrored by tests, exported to [`docs/dialects.md`](https://github.com/vibeorm/vibeorm/blob/master/docs/dialects.md). A feature the dialect cannot express throws `VibeError` code `VIBE_UNSUPPORTED_CAPABILITY` at the earliest knowable moment (generate, then build, then execute) — it never silently misbehaves.
+
+Refused:
+
+- `scalarArrays` — scalar list columns are rejected at generate and migrate time.
+- `lateralJoin` — the `"join"` relation strategy is refused. Use the default `"query"` strategy.
+- `partialIndexes` — partial (predicate) indexes are rejected at migrate time.
+- `createManyAndReturn` — refused; use `createMany` and re-query.
+
+Handled by a documented fallback:
+
+- No `RETURNING`: mutations read the row back via `SELECT LAST_INSERT_ID()` plus a re-select, inside one transaction when the key is database-assigned. That is sound because `transaction()` pins one pooled connection and `LAST_INSERT_ID()` is per-connection state.
+- Upserts render `ON DUPLICATE KEY UPDATE` (no conflict-target refinement); "do nothing" renders `INSERT IGNORE`, which is broader — it downgrades other row-level errors to warnings too.
+- `mode: "insensitive"` renders `LOWER(x) LIKE LOWER(?)`, redundant on the default `_ci` collations and index-degrading.
+- `distinct` keeps the first row per key client-side, in the query's row order.
+- Null ordering is emulated with an `IS NULL` sort term; `OFFSET` without `LIMIT` uses the documented huge-limit idiom.
+- DDL auto-commits, so the migration runner records per-statement progress and a failed migration resumes instead of re-running.
+
+Native: enums and a real JSON column type; `fulltext` is the search engine.
+
+Transaction `timeout` is implemented as `SET SESSION MAX_EXECUTION_TIME`, which **bounds SELECT statements only** — INSERT/UPDATE/DELETE/DDL inside the transaction run unbounded. The setting is reset in `finally`; if the reset fails the connection is destroyed rather than returned to the pool. Nested `transaction()` calls become savepoints and refuse `isolationLevel`/`timeout` with `VIBE_VALIDATION`.
+
+On the default `_ci` collations both `=`/`IN` and `LIKE` are case-insensitive; `mode: "strict"` casts the operand to `BINARY` for byte-exact comparison. See [`docs/dialect-notes.md`](https://github.com/vibeorm/vibeorm/blob/master/docs/dialect-notes.md).
+
+## Error mapping
+
+Every driver failure becomes a `VibeError` with the original error as `cause`; `meta` carries `errno`, the symbolic `code`, `sqlState`, a trimmed `sqlMessage`, and `reason` where applicable.
+
+| errno | MySQL name | VibeError code | `meta.reason` |
+|---|---|---|---|
+| 1062 / 1586 / 1761 / 1762 | duplicate key family | `VIBE_UNIQUE_VIOLATION` | |
+| 1216 / 1217 / 1451 / 1452 | foreign key family | `VIBE_FK_VIOLATION` | |
+| 1048 | null violation | `VIBE_VALIDATION` | |
+| 1264 | out of range | `VIBE_VALIDATION` | |
+| 1265 | data truncated (bad ENUM value or truncated numeric string; a hard error in strict mode) | `VIBE_VALIDATION` | |
+| 1292 | truncated wrong value, e.g. a bad datetime literal | `VIBE_VALIDATION` | |
+| 1364 | no default | `VIBE_VALIDATION` | |
+| 1366 | wrong-typed value for column | `VIBE_VALIDATION` | |
+| 1406 | data too long | `VIBE_VALIDATION` | |
+| 3819 | check violation | `VIBE_VALIDATION` | |
+| 1213 | deadlock | `VIBE_TRANSACTION` | `"deadlock"` |
+| 1205 | lock wait timeout | `VIBE_TRANSACTION` | `"timeout"` |
+| 3024 | query interrupted (`max_execution_time`) | `VIBE_TRANSACTION` | `"timeout"` |
+| everything else, including 1044/1045, `ECONNREFUSED`, `PROTOCOL_CONNECTION_LOST`, `ETIMEDOUT` | | `VIBE_ADAPTER` | |
+
+`VibeError`s pass through unchanged, and a transaction callback's own error is rethrown identically.
+
+## Links
+
+- [Documentation](https://github.com/vibeorm/vibeorm/tree/master/docs)
+- [Getting started](https://github.com/vibeorm/vibeorm/blob/master/docs/getting-started.md)
+- [Dialect capability tables](https://github.com/vibeorm/vibeorm/blob/master/docs/dialects.md)
+- [Repository and issues](https://github.com/vibeorm/vibeorm)
+- MIT licensed

package/dist/errors.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Driver-error mapping for mysql2.
+ *
+ * Constitution rule 5: a raw driver error never escapes an adapter. Every
+ * failure becomes a `VibeError` with a stable code, the driver error attached
+ * as `cause`, and the MySQL errno / symbolic code / SQLSTATE / server message
+ * in `meta`.
+ *
+ * mysql2 errors carry `errno` (the numeric MySQL server error, e.g. 1062),
+ * `code` (the symbolic name, `ER_DUP_ENTRY`, or a client-side string like
+ * `ECONNREFUSED` / `PROTOCOL_CONNECTION_LOST`), `sqlState` and `sqlMessage`.
+ * The table is keyed by `errno` because it is the stable server-side identity;
+ * client-side failures have no errno and fall through to `VIBE_ADAPTER`.
+ */
+import { VibeError, type VibeErrorCode } from "@vibeorm/schema";
+/**
+ * MySQL server errno → stable VibeError code. Frozen and mirrored by tests;
+ * anything absent from this table maps to `VIBE_ADAPTER` — including access
+ * failures (1044 `ER_DBACCESS_DENIED_ERROR`, 1045 `ER_ACCESS_DENIED_ERROR`)
+ * and every client-side connection error (`ECONNREFUSED`,
+ * `PROTOCOL_CONNECTION_LOST`, `ETIMEDOUT`), which carry no errno at all.
+ */
+export declare const MYSQL_ERRNO_ERROR_CODES: Readonly<Record<number, VibeErrorCode>>;
+/** Errnos that additionally explain themselves through `meta.reason`. */
+export declare const MYSQL_ERRNO_REASONS: Readonly<Record<number, string>>;
+/**
+ * Extract the numeric MySQL errno from a mysql2 error. Client-side failures
+ * (`ECONNREFUSED`, `PROTOCOL_CONNECTION_LOST`, …) have no numeric errno and
+ * yield `undefined`.
+ */
+export declare function mysqlErrorErrno(params: {
+    error: unknown;
+}): number | undefined;
+/**
+ * Map any error thrown by mysql2 onto a `VibeError`.
+ *
+ * A `VibeError` passes through unchanged, so an error raised deeper inside the
+ * ORM (or by a nested adapter call) is never re-wrapped, and a user callback's
+ * error is rethrown identically.
+ */
+export declare function mapMysqlDriverError(params: {
+    error: unknown;
+}): VibeError;
+/** Run a driver call, mapping anything it throws onto a `VibeError`. */
+export declare function runMapped<T>(fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,SAAS,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIhE;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAoD1E,CAAC;AAEH,yEAAyE;AACzE,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAO/D,CAAC;AASH;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAK9E;AAID;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,CA2BzE;AAED,wEAAwE;AACxE,wBAAsB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAMnE"}

package/dist/index.d.ts

@@ -0,0 +1,159 @@
+/**
+ * @vibeorm/adapter-mysql — mysql2 adapter for VibeORM v2.
+ *
+ * Runs on Bun and Node over `mysql2/promise`. Owns pooling, transactions
+ * (nested → savepoints on the same pinned connection) and driver-error
+ * mapping. Only `VibeError` ever escapes.
+ *
+ * SAME-CONNECTION GUARANTEE (board #7): `transaction()` checks ONE connection
+ * out of the pool and every operation on the callback's adapter — `execute`,
+ * `executeUnsafe`, nested `transaction` — runs on that same connection until
+ * commit/rollback. That pinning is what makes `LAST_INSERT_ID()` sound: the
+ * runtime wraps DB-assigned-key creates in `adapter.transaction` and issues
+ * `SELECT LAST_INSERT_ID() AS id` via `executeUnsafe`, and LAST_INSERT_ID() is
+ * per-connection state in MySQL — on any other connection it would answer for
+ * someone else's INSERT.
+ *
+ * Driver configuration is pinned to the runtime's MYSQL_CODECS contract
+ * (packages/runtime/src/codecs.ts) — see {@link MysqlPoolConfig}.
+ */
+import type { DatabaseAdapter } from "@vibeorm/runtime";
+/** The parts of a mysql2 `PoolConnection` this adapter uses. */
+export type MysqlConnectionLike = {
+    /** Binary protocol — prepared statements, cached per connection by mysql2. */
+    execute(text: string, values?: unknown[]): Promise<[unknown, unknown]>;
+    /** Text protocol — raw path and transaction-control statements. */
+    query(text: string, values?: unknown[]): Promise<[unknown, unknown]>;
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    ping(): Promise<void>;
+    release(): void;
+    destroy(): void;
+};
+/** The parts of a mysql2 promise `Pool` this adapter uses. */
+export type MysqlPoolLike = {
+    execute(text: string, values?: unknown[]): Promise<[unknown, unknown]>;
+    query(text: string, values?: unknown[]): Promise<[unknown, unknown]>;
+    getConnection(): Promise<MysqlConnectionLike>;
+    end(): Promise<void>;
+};
+/**
+ * The exact configuration this adapter hands to `mysql2.createPool`. The
+ * literal-typed fields are pinned to the runtime's MYSQL_CODECS contract and
+ * are not user-overridable:
+ *
+ * - `decimalNumbers: false` — DECIMAL comes back as a string; the Decimal
+ *   codec keeps it a string (no float rounding) and trims the fixed-scale
+ *   padding MySQL reports (`DECIMAL(65, 30)` → `"42.420…00"` → `"42.42"`).
+ * - `supportBigNumbers: true` + `bigNumberStrings: true` — BIGINT (and
+ *   DECIMAL) always come back as strings, never a precision-lossy JS number;
+ *   the BigInt codec decodes strings exactly.
+ * - `dateStrings: false` — DATETIME comes back as a JS `Date`; the DateTime
+ *   codec passes `Date` through in both directions.
+ * - `jsonStrings: false` — JSON columns come back already parsed, which is
+ *   what the Json codec's decode expects from mysql2.
+ * - `namedPlaceholders: false` — the mysql dialect renders positional `?`.
+ * - `multipleStatements` defaults to false: the ORM never batches, and
+ *   @vibeorm/migrate's mysql runner applies DDL per-statement anyway (DDL
+ *   auto-commits, so per-statement progress tracking needs it).
+ */
+export type MysqlPoolConfig = {
+    readonly uri?: string;
+    readonly host?: string;
+    readonly port?: number;
+    readonly user?: string;
+    readonly password?: string;
+    readonly database?: string;
+    readonly connectionLimit?: number;
+    readonly charset?: string;
+    readonly timezone: string;
+    readonly decimalNumbers: false;
+    readonly supportBigNumbers: true;
+    readonly bigNumberStrings: true;
+    readonly dateStrings: false;
+    readonly jsonStrings: false;
+    readonly namedPlaceholders: false;
+    readonly multipleStatements: boolean;
+};
+/**
+ * Options for {@link mysqlAdapter}. Point it at a connection URL **or** at
+ * discrete `host`/`port`/`user`/`password`/`database` fields (mysql2 accepts
+ * both; when both are given the discrete fields win — mysql2 merges the parsed
+ * URL underneath explicit config), or hand it a pool you already own.
+ */
+export type MysqlAdapterOptions = {
+    /** MySQL connection URL (`mysql://user:pw@host:3306/db`). Defaults to `process.env.MYSQL_URL`. */
+    readonly url?: string;
+    readonly host?: string;
+    readonly port?: number;
+    readonly user?: string;
+    readonly password?: string;
+    readonly database?: string;
+    /**
+     * An existing mysql2 promise pool to use instead of creating one. The
+     * adapter never ends a pool it did not create, so `disconnect()` is a no-op
+     * in this mode. The pool MUST be configured to the codec contract
+     * ({@link MysqlPoolConfig}) — the adapter cannot verify it.
+     */
+    readonly pool?: MysqlPoolLike;
+    /** Maximum pooled connections (mysql2 default 10). Ignored when `pool` is given. */
+    readonly connectionLimit?: number;
+    /**
+     * mysql2 `timezone`, default `"Z"`: the codec table stores DateTime as UTC
+     * in `DATETIME(3)` columns, and DATETIME has no zone of its own — with
+     * `"Z"` mysql2 serializes outgoing `Date`s as UTC and parses incoming
+     * DATETIME text as UTC, so the instant round-trips regardless of the server
+     * or process time zone. mysql2's own default (`"local"`) would silently
+     * shift values by the process offset.
+     */
+    readonly timezone?: string;
+    /** Connection charset/collation (mysql2 default `utf8mb4_general_ci`). */
+    readonly charset?: string;
+    /**
+     * Allow multiple statements per `executeUnsafe` call (default false). Leave
+     * it off: the ORM never batches, @vibeorm/migrate applies DDL per statement,
+     * and enabling it widens the SQL-injection blast radius of raw queries.
+     */
+    readonly multipleStatements?: boolean;
+    /**
+     * Pool factory — a test seam. Defaults to `mysql2/promise`'s `createPool`;
+     * tests inject a recording fake here to assert the exact config the adapter
+     * builds. Ignored when `pool` is given.
+     */
+    readonly createPool?: (config: MysqlPoolConfig) => MysqlPoolLike;
+};
+/**
+ * Create a VibeORM adapter backed by mysql2.
+ *
+ * @example
+ * ```ts
+ * const adapter = mysqlAdapter({ url: process.env.MYSQL_URL, connectionLimit: 20 });
+ * await adapter.connect();
+ * const rows = await adapter.execute({ text: "SELECT * FROM `User` WHERE `id` = ?", values: [1] });
+ * ```
+ *
+ * @example Discrete fields, or reusing a pool you already own
+ * ```ts
+ * const adapter = mysqlAdapter({ host: "127.0.0.1", port: 3306, user: "app", password: "pw", database: "app" });
+ * const shared = mysqlAdapter({ pool: existingPool });
+ * ```
+ *
+ * ORM path (`execute`) uses mysql2's binary protocol (`pool.execute`), which
+ * prepares statements and caches them per connection keyed by statement text
+ * (mysql2's `maxPreparedStatements` LRU, default 16000). Raw path
+ * (`executeUnsafe`) uses the text protocol (`pool.query`) — no statement
+ * cache, and DDL (which the binary protocol cannot prepare) works.
+ *
+ * Parameters arrive PRE-ENCODED by the runtime codec table: Json is already a
+ * string, DateTime is a `Date` (mysql2 serializes it per `timezone`), BigInt
+ * is a string. The adapter forwards values verbatim — no second conversion.
+ */
+export declare function mysqlAdapter(options?: MysqlAdapterOptions): DatabaseAdapter;
+export { MYSQL_ERRNO_ERROR_CODES, MYSQL_ERRNO_REASONS, mapMysqlDriverError, mysqlErrorErrno, runMapped, } from "./errors.ts";
+export { isResultSetHeader, normalizeDriverResult } from "./results.ts";
+export { createSavepointCounter, nextSavepointName } from "./savepoints.ts";
+export type { SavepointCounter } from "./savepoints.ts";
+export { ISOLATION_LEVEL_SQL, RESET_MAX_EXECUTION_TIME_SQL, classifyRawTransactionControl, maxExecutionTimeStatement, refuseNestedTransactionOptions, setIsolationLevelStatement, } from "./transaction-sql.ts";
+export type { RawTransactionControl } from "./transaction-sql.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,378 @@
+// @bun
+// packages/adapter-mysql/src/index.ts
+import { internalError } from "@vibeorm/schema";
+import { createPool as mysql2CreatePool } from "mysql2/promise";
+
+// packages/adapter-mysql/src/errors.ts
+import { VibeError } from "@vibeorm/schema";
+var MYSQL_ERRNO_ERROR_CODES = Object.freeze({
+  1062: "VIBE_UNIQUE_VIOLATION",
+  1586: "VIBE_UNIQUE_VIOLATION",
+  1761: "VIBE_UNIQUE_VIOLATION",
+  1762: "VIBE_UNIQUE_VIOLATION",
+  1216: "VIBE_FK_VIOLATION",
+  1217: "VIBE_FK_VIOLATION",
+  1451: "VIBE_FK_VIOLATION",
+  1452: "VIBE_FK_VIOLATION",
+  1048: "VIBE_VALIDATION",
+  1264: "VIBE_VALIDATION",
+  1364: "VIBE_VALIDATION",
+  1406: "VIBE_VALIDATION",
+  1265: "VIBE_VALIDATION",
+  1366: "VIBE_VALIDATION",
+  1292: "VIBE_VALIDATION",
+  3819: "VIBE_VALIDATION",
+  1213: "VIBE_TRANSACTION",
+  1205: "VIBE_TRANSACTION",
+  3024: "VIBE_TRANSACTION"
+});
+var MYSQL_ERRNO_REASONS = Object.freeze({
+  1213: "deadlock",
+  1205: "timeout",
+  3024: "timeout"
+});
+function readStringField(params) {
+  const value = params.source[params.key];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function mysqlErrorErrno(params) {
+  const { error } = params;
+  if (error === null || typeof error !== "object")
+    return;
+  const errno = error.errno;
+  return typeof errno === "number" && Number.isInteger(errno) ? errno : undefined;
+}
+function mapMysqlDriverError(params) {
+  const { error } = params;
+  if (error instanceof VibeError)
+    return error;
+  const source = error !== null && typeof error === "object" ? error : {};
+  const errno = mysqlErrorErrno({ error });
+  const code = (errno === undefined ? undefined : MYSQL_ERRNO_ERROR_CODES[errno]) ?? "VIBE_ADAPTER";
+  const meta = {};
+  if (errno !== undefined)
+    meta.errno = errno;
+  const symbolicCode = readStringField({ source, key: "code" });
+  if (symbolicCode !== undefined)
+    meta.code = symbolicCode;
+  const sqlState = readStringField({ source, key: "sqlState" });
+  if (sqlState !== undefined)
+    meta.sqlState = sqlState;
+  const sqlMessage = readStringField({ source, key: "sqlMessage" });
+  if (sqlMessage !== undefined)
+    meta.sqlMessage = sqlMessage.trim();
+  const reason = errno === undefined ? undefined : MYSQL_ERRNO_REASONS[errno];
+  if (reason !== undefined)
+    meta.reason = reason;
+  const message = readStringField({ source, key: "message" }) ?? (sqlMessage !== undefined ? sqlMessage.trim() : undefined) ?? (typeof error === "string" ? error : "unknown mysql driver error");
+  return new VibeError({ code, message, meta, cause: error });
+}
+async function runMapped(fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    throw mapMysqlDriverError({ error });
+  }
+}
+
+// packages/adapter-mysql/src/results.ts
+function isResultSetHeader(params) {
+  const { value } = params;
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const source = value;
+  return typeof source.affectedRows === "number" && typeof source.serverStatus === "number";
+}
+function normalizeSingle(value) {
+  if (Array.isArray(value)) {
+    return { rows: value, affectedRows: 0 };
+  }
+  if (isResultSetHeader({ value })) {
+    return { rows: [], affectedRows: value.affectedRows };
+  }
+  return { rows: [], affectedRows: 0 };
+}
+function normalizeDriverResult(params) {
+  const { result } = params;
+  if (Array.isArray(result)) {
+    const last = result.at(-1);
+    if (last !== undefined && (Array.isArray(last) || isResultSetHeader({ value: last }))) {
+      return normalizeSingle(last);
+    }
+    return { rows: result, affectedRows: 0 };
+  }
+  return normalizeSingle(result);
+}
+
+// packages/adapter-mysql/src/savepoints.ts
+function createSavepointCounter() {
+  return { n: 0 };
+}
+function nextSavepointName(params) {
+  return `vibeorm_sp_${params.counter.n++}`;
+}
+
+// packages/adapter-mysql/src/transaction-sql.ts
+import { VibeError as VibeError2 } from "@vibeorm/schema";
+var ISOLATION_LEVEL_SQL = Object.freeze({
+  ReadCommitted: "READ COMMITTED",
+  RepeatableRead: "REPEATABLE READ",
+  Serializable: "SERIALIZABLE"
+});
+function setIsolationLevelStatement(params) {
+  return `SET TRANSACTION ISOLATION LEVEL ${ISOLATION_LEVEL_SQL[params.isolationLevel]}`;
+}
+function maxExecutionTimeStatement(params) {
+  const { timeout } = params;
+  if (!Number.isInteger(timeout) || timeout < 0) {
+    throw new VibeError2({
+      code: "VIBE_VALIDATION",
+      message: `transaction timeout must be a non-negative integer of milliseconds, received ${String(timeout)}`,
+      meta: { timeout }
+    });
+  }
+  return `SET SESSION MAX_EXECUTION_TIME = ${timeout}`;
+}
+var RESET_MAX_EXECUTION_TIME_SQL = "SET SESSION MAX_EXECUTION_TIME = DEFAULT";
+var RAW_OPEN_PATTERN = /^\s*(?:begin|start\s+transaction)\b[^;]*;?\s*$/i;
+var RAW_CLOSE_PATTERN = /^\s*(?:commit|rollback)(?:\s+work)?\s*;?\s*$/i;
+function classifyRawTransactionControl(params) {
+  if (RAW_OPEN_PATTERN.test(params.text))
+    return "open";
+  if (RAW_CLOSE_PATTERN.test(params.text))
+    return "close";
+  return null;
+}
+function refuseNestedTransactionOptions(params) {
+  const { options, provider } = params;
+  if (options === undefined)
+    return;
+  const passed = [];
+  if (options.isolationLevel !== undefined)
+    passed.push("isolationLevel");
+  if (options.timeout !== undefined)
+    passed.push("timeout");
+  if (passed.length === 0)
+    return;
+  const meta = { provider, nested: true };
+  if (options.isolationLevel !== undefined)
+    meta.isolationLevel = options.isolationLevel;
+  if (options.timeout !== undefined)
+    meta.timeout = options.timeout;
+  throw new VibeError2({
+    code: "VIBE_VALIDATION",
+    message: `nested transactions run as savepoints and cannot honor ${passed.join(" or ")} \u2014 a savepoint cannot change the isolation level of the transaction it joins, and a nested timeout is not enforceable; pass options on the top-level $transaction`,
+    meta
+  });
+}
+
+// packages/adapter-mysql/src/index.ts
+var DIALECT = "mysql";
+var PROVIDER = "mysql";
+var WIRE = Object.freeze({ dateTime: "native", json: "parsed", numbers: "native" });
+function defaultCreatePool(config) {
+  return mysql2CreatePool(config);
+}
+function throwOnArrayParam(values) {
+  throw internalError({
+    message: "formatArrayParam called on the mysql adapter \u2014 the mysql dialect expands scalar-list parameters into IN (?, ?, \u2026) placeholders, so the runtime should have expanded this array before binding",
+    meta: { length: values.length }
+  });
+}
+function mysqlAdapter(options) {
+  let pool = null;
+  let ownsPool = false;
+  let rawSession = null;
+  function getPool() {
+    if (pool !== null)
+      return pool;
+    if (options?.pool !== undefined) {
+      pool = options.pool;
+      ownsPool = false;
+      return pool;
+    }
+    const config = {
+      uri: options?.url ?? process.env.MYSQL_URL,
+      host: options?.host,
+      port: options?.port,
+      user: options?.user,
+      password: options?.password,
+      database: options?.database,
+      connectionLimit: options?.connectionLimit,
+      charset: options?.charset,
+      timezone: options?.timezone ?? "Z",
+      decimalNumbers: false,
+      supportBigNumbers: true,
+      bigNumberStrings: true,
+      dateStrings: false,
+      jsonStrings: false,
+      namedPlaceholders: false,
+      multipleStatements: options?.multipleStatements ?? false
+    };
+    pool = (options?.createPool ?? defaultCreatePool)(config);
+    ownsPool = true;
+    return pool;
+  }
+  async function runExecute(params) {
+    const [result] = await runMapped(() => params.queryable.execute(params.text, params.values));
+    return normalizeDriverResult({ result }).rows;
+  }
+  async function runExecuteUnsafe(params) {
+    const [result] = await runMapped(() => params.queryable.query(params.text, params.values));
+    return normalizeDriverResult({ result });
+  }
+  function createConnectionAdapter(params) {
+    const { conn, savepointCounter } = params;
+    return {
+      dialect: DIALECT,
+      provider: PROVIDER,
+      wire: WIRE,
+      async execute(execParams) {
+        return runExecute({ queryable: conn, ...execParams });
+      },
+      async executeUnsafe(execParams) {
+        return runExecuteUnsafe({ queryable: conn, ...execParams });
+      },
+      async transaction(fn, nestedOptions) {
+        refuseNestedTransactionOptions({ options: nestedOptions, provider: PROVIDER });
+        const savepoint = nextSavepointName({ counter: savepointCounter });
+        await runMapped(() => conn.query(`SAVEPOINT ${savepoint}`));
+        try {
+          const result = await fn(createConnectionAdapter({ conn, savepointCounter }));
+          await runMapped(() => conn.query(`RELEASE SAVEPOINT ${savepoint}`));
+          return result;
+        } catch (error) {
+          try {
+            await conn.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+          } catch {}
+          throw error;
+        }
+      },
+      async connect() {},
+      async disconnect() {},
+      formatArrayParam(values) {
+        return throwOnArrayParam(values);
+      }
+    };
+  }
+  return {
+    dialect: DIALECT,
+    provider: PROVIDER,
+    wire: WIRE,
+    async execute(params) {
+      return runExecute({ queryable: getPool(), ...params });
+    },
+    async executeUnsafe(params) {
+      const control = classifyRawTransactionControl({ text: params.text });
+      if (rawSession !== null) {
+        if (control === "close") {
+          const session = rawSession;
+          rawSession = null;
+          try {
+            return await runExecuteUnsafe({ queryable: session, ...params });
+          } finally {
+            session.release();
+          }
+        }
+        return runExecuteUnsafe({ queryable: rawSession, ...params });
+      }
+      if (control === "open") {
+        const conn = await runMapped(() => getPool().getConnection());
+        try {
+          const result = await runExecuteUnsafe({ queryable: conn, ...params });
+          rawSession = conn;
+          return result;
+        } catch (error) {
+          conn.release();
+          throw error;
+        }
+      }
+      return runExecuteUnsafe({ queryable: getPool(), ...params });
+    },
+    async transaction(fn, transactionOptions) {
+      const timeoutText = transactionOptions?.timeout === undefined ? undefined : maxExecutionTimeStatement({ timeout: transactionOptions.timeout });
+      const conn = await runMapped(() => getPool().getConnection());
+      try {
+        if (timeoutText !== undefined) {
+          await runMapped(() => conn.query(timeoutText));
+        }
+        const isolationLevel = transactionOptions?.isolationLevel;
+        if (isolationLevel !== undefined) {
+          const isolationText = setIsolationLevelStatement({ isolationLevel });
+          await runMapped(() => conn.query(isolationText));
+        }
+        await runMapped(() => conn.beginTransaction());
+        try {
+          const result = await fn(createConnectionAdapter({ conn, savepointCounter: createSavepointCounter() }));
+          await runMapped(() => conn.commit());
+          return result;
+        } catch (error) {
+          try {
+            await conn.rollback();
+          } catch {}
+          throw error;
+        }
+      } finally {
+        let poisoned = false;
+        if (timeoutText !== undefined) {
+          try {
+            await conn.query(RESET_MAX_EXECUTION_TIME_SQL);
+          } catch {
+            poisoned = true;
+          }
+        }
+        if (poisoned) {
+          conn.destroy();
+        } else {
+          conn.release();
+        }
+      }
+    },
+    async connect() {
+      const conn = await runMapped(() => getPool().getConnection());
+      try {
+        await runMapped(() => conn.ping());
+      } finally {
+        conn.release();
+      }
+    },
+    async disconnect() {
+      if (rawSession !== null) {
+        const session = rawSession;
+        rawSession = null;
+        try {
+          await session.query("ROLLBACK");
+        } catch {}
+        session.release();
+      }
+      if (pool !== null && ownsPool) {
+        const closing = pool;
+        pool = null;
+        await runMapped(() => closing.end());
+      }
+    },
+    formatArrayParam(values) {
+      return throwOnArrayParam(values);
+    }
+  };
+}
+export {
+  setIsolationLevelStatement,
+  runMapped,
+  refuseNestedTransactionOptions,
+  normalizeDriverResult,
+  nextSavepointName,
+  mysqlErrorErrno,
+  mysqlAdapter,
+  maxExecutionTimeStatement,
+  mapMysqlDriverError,
+  isResultSetHeader,
+  createSavepointCounter,
+  classifyRawTransactionControl,
+  RESET_MAX_EXECUTION_TIME_SQL,
+  MYSQL_ERRNO_REASONS,
+  MYSQL_ERRNO_ERROR_CODES,
+  ISOLATION_LEVEL_SQL
+};
+
+//# debugId=81C757629DAE03DB64756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,14 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts", "../src/errors.ts", "../src/results.ts", "../src/savepoints.ts", "../src/transaction-sql.ts"],
+  "sourcesContent": [
+    "/**\n * @vibeorm/adapter-mysql — mysql2 adapter for VibeORM v2.\n *\n * Runs on Bun and Node over `mysql2/promise`. Owns pooling, transactions\n * (nested → savepoints on the same pinned connection) and driver-error\n * mapping. Only `VibeError` ever escapes.\n *\n * SAME-CONNECTION GUARANTEE (board #7): `transaction()` checks ONE connection\n * out of the pool and every operation on the callback's adapter — `execute`,\n * `executeUnsafe`, nested `transaction` — runs on that same connection until\n * commit/rollback. That pinning is what makes `LAST_INSERT_ID()` sound: the\n * runtime wraps DB-assigned-key creates in `adapter.transaction` and issues\n * `SELECT LAST_INSERT_ID() AS id` via `executeUnsafe`, and LAST_INSERT_ID() is\n * per-connection state in MySQL — on any other connection it would answer for\n * someone else's INSERT.\n *\n * Driver configuration is pinned to the runtime's MYSQL_CODECS contract\n * (packages/runtime/src/codecs.ts) — see {@link MysqlPoolConfig}.\n */\n\nimport type { DatabaseAdapter, QueryResult, TransactionOptions, WireFidelity } from \"@vibeorm/runtime\";\nimport type { Dialect, Provider } from \"@vibeorm/schema\";\nimport { internalError } from \"@vibeorm/schema\";\nimport { createPool as mysql2CreatePool } from \"mysql2/promise\";\nimport { mapMysqlDriverError, runMapped } from \"./errors.ts\";\nimport { normalizeDriverResult } from \"./results.ts\";\nimport { createSavepointCounter, nextSavepointName, type SavepointCounter } from \"./savepoints.ts\";\nimport {\n  RESET_MAX_EXECUTION_TIME_SQL,\n  classifyRawTransactionControl,\n  maxExecutionTimeStatement,\n  refuseNestedTransactionOptions,\n  setIsolationLevelStatement,\n} from \"./transaction-sql.ts\";\n\n// ─── Minimal mysql2 surface ───────────────────────────────────────\n\n/** The parts of a mysql2 `PoolConnection` this adapter uses. */\nexport type MysqlConnectionLike = {\n  /** Binary protocol — prepared statements, cached per connection by mysql2. */\n  execute(text: string, values?: unknown[]): Promise<[unknown, unknown]>;\n  /** Text protocol — raw path and transaction-control statements. */\n  query(text: string, values?: unknown[]): Promise<[unknown, unknown]>;\n  beginTransaction(): Promise<void>;\n  commit(): Promise<void>;\n  rollback(): Promise<void>;\n  ping(): Promise<void>;\n  release(): void;\n  destroy(): void;\n};\n\n/** The parts of a mysql2 promise `Pool` this adapter uses. */\nexport type MysqlPoolLike = {\n  execute(text: string, values?: unknown[]): Promise<[unknown, unknown]>;\n  query(text: string, values?: unknown[]): Promise<[unknown, unknown]>;\n  getConnection(): Promise<MysqlConnectionLike>;\n  end(): Promise<void>;\n};\n\n/** Anything that can run a statement: the pool itself or a pinned connection. */\ntype Queryable = Pick<MysqlConnectionLike, \"execute\" | \"query\">;\n\n// ─── Pool config ──────────────────────────────────────────────────\n\n/**\n * The exact configuration this adapter hands to `mysql2.createPool`. The\n * literal-typed fields are pinned to the runtime's MYSQL_CODECS contract and\n * are not user-overridable:\n *\n * - `decimalNumbers: false` — DECIMAL comes back as a string; the Decimal\n *   codec keeps it a string (no float rounding) and trims the fixed-scale\n *   padding MySQL reports (`DECIMAL(65, 30)` → `\"42.420…00\"` → `\"42.42\"`).\n * - `supportBigNumbers: true` + `bigNumberStrings: true` — BIGINT (and\n *   DECIMAL) always come back as strings, never a precision-lossy JS number;\n *   the BigInt codec decodes strings exactly.\n * - `dateStrings: false` — DATETIME comes back as a JS `Date`; the DateTime\n *   codec passes `Date` through in both directions.\n * - `jsonStrings: false` — JSON columns come back already parsed, which is\n *   what the Json codec's decode expects from mysql2.\n * - `namedPlaceholders: false` — the mysql dialect renders positional `?`.\n * - `multipleStatements` defaults to false: the ORM never batches, and\n *   @vibeorm/migrate's mysql runner applies DDL per-statement anyway (DDL\n *   auto-commits, so per-statement progress tracking needs it).\n */\nexport type MysqlPoolConfig = {\n  readonly uri?: string;\n  readonly host?: string;\n  readonly port?: number;\n  readonly user?: string;\n  readonly password?: string;\n  readonly database?: string;\n  readonly connectionLimit?: number;\n  readonly charset?: string;\n  readonly timezone: string;\n  readonly decimalNumbers: false;\n  readonly supportBigNumbers: true;\n  readonly bigNumberStrings: true;\n  readonly dateStrings: false;\n  readonly jsonStrings: false;\n  readonly namedPlaceholders: false;\n  readonly multipleStatements: boolean;\n};\n\n// ─── Options ──────────────────────────────────────────────────────\n\n/**\n * Options for {@link mysqlAdapter}. Point it at a connection URL **or** at\n * discrete `host`/`port`/`user`/`password`/`database` fields (mysql2 accepts\n * both; when both are given the discrete fields win — mysql2 merges the parsed\n * URL underneath explicit config), or hand it a pool you already own.\n */\nexport type MysqlAdapterOptions = {\n  /** MySQL connection URL (`mysql://user:pw@host:3306/db`). Defaults to `process.env.MYSQL_URL`. */\n  readonly url?: string;\n  readonly host?: string;\n  readonly port?: number;\n  readonly user?: string;\n  readonly password?: string;\n  readonly database?: string;\n  /**\n   * An existing mysql2 promise pool to use instead of creating one. The\n   * adapter never ends a pool it did not create, so `disconnect()` is a no-op\n   * in this mode. The pool MUST be configured to the codec contract\n   * ({@link MysqlPoolConfig}) — the adapter cannot verify it.\n   */\n  readonly pool?: MysqlPoolLike;\n  /** Maximum pooled connections (mysql2 default 10). Ignored when `pool` is given. */\n  readonly connectionLimit?: number;\n  /**\n   * mysql2 `timezone`, default `\"Z\"`: the codec table stores DateTime as UTC\n   * in `DATETIME(3)` columns, and DATETIME has no zone of its own — with\n   * `\"Z\"` mysql2 serializes outgoing `Date`s as UTC and parses incoming\n   * DATETIME text as UTC, so the instant round-trips regardless of the server\n   * or process time zone. mysql2's own default (`\"local\"`) would silently\n   * shift values by the process offset.\n   */\n  readonly timezone?: string;\n  /** Connection charset/collation (mysql2 default `utf8mb4_general_ci`). */\n  readonly charset?: string;\n  /**\n   * Allow multiple statements per `executeUnsafe` call (default false). Leave\n   * it off: the ORM never batches, @vibeorm/migrate applies DDL per statement,\n   * and enabling it widens the SQL-injection blast radius of raw queries.\n   */\n  readonly multipleStatements?: boolean;\n  /**\n   * Pool factory — a test seam. Defaults to `mysql2/promise`'s `createPool`;\n   * tests inject a recording fake here to assert the exact config the adapter\n   * builds. Ignored when `pool` is given.\n   */\n  readonly createPool?: (config: MysqlPoolConfig) => MysqlPoolLike;\n};\n\n// ─── Adapter ──────────────────────────────────────────────────────\n\nconst DIALECT: Dialect = \"mysql\";\nconst PROVIDER: Provider = \"mysql\";\n\n/**\n * mysql2 wire (board #30, live-verified on both execute paths, 8.4):\n * datetime(3) → `Date` (under the adapter's pinned `timezone: \"Z\"`), JSON →\n * parsed values, int/double → numbers. (BIGINT arrives as a string and\n * TINYINT(1) as 0/1 — BigInt/Boolean decoding stays.)\n */\nconst WIRE: WireFidelity = Object.freeze({ dateTime: \"native\", json: \"parsed\", numbers: \"native\" } as const);\n\nfunction defaultCreatePool(config: MysqlPoolConfig): MysqlPoolLike {\n  // Single cast seam: mysql2's Pool satisfies MysqlPoolLike structurally, but\n  // its generic overloads don't reduce to our plain signatures.\n  return mysql2CreatePool(config as Parameters<typeof mysql2CreatePool>[0]) as unknown as MysqlPoolLike;\n}\n\n/** Scalar-array params must never reach this adapter — the dialect expands IN. */\nfunction throwOnArrayParam(values: unknown[]): never {\n  throw internalError({\n    message:\n      \"formatArrayParam called on the mysql adapter — the mysql dialect expands scalar-list parameters into IN (?, ?, …) placeholders, so the runtime should have expanded this array before binding\",\n    meta: { length: values.length },\n  });\n}\n\n/**\n * Create a VibeORM adapter backed by mysql2.\n *\n * @example\n * ```ts\n * const adapter = mysqlAdapter({ url: process.env.MYSQL_URL, connectionLimit: 20 });\n * await adapter.connect();\n * const rows = await adapter.execute({ text: \"SELECT * FROM `User` WHERE `id` = ?\", values: [1] });\n * ```\n *\n * @example Discrete fields, or reusing a pool you already own\n * ```ts\n * const adapter = mysqlAdapter({ host: \"127.0.0.1\", port: 3306, user: \"app\", password: \"pw\", database: \"app\" });\n * const shared = mysqlAdapter({ pool: existingPool });\n * ```\n *\n * ORM path (`execute`) uses mysql2's binary protocol (`pool.execute`), which\n * prepares statements and caches them per connection keyed by statement text\n * (mysql2's `maxPreparedStatements` LRU, default 16000). Raw path\n * (`executeUnsafe`) uses the text protocol (`pool.query`) — no statement\n * cache, and DDL (which the binary protocol cannot prepare) works.\n *\n * Parameters arrive PRE-ENCODED by the runtime codec table: Json is already a\n * string, DateTime is a `Date` (mysql2 serializes it per `timezone`), BigInt\n * is a string. The adapter forwards values verbatim — no second conversion.\n */\nexport function mysqlAdapter(options?: MysqlAdapterOptions): DatabaseAdapter {\n  let pool: MysqlPoolLike | null = null;\n  let ownsPool = false;\n\n  /**\n   * The pinned connection of an OPEN raw transaction — session affinity for\n   * the raw path. A raw `BEGIN` … `COMMIT` sequence over `executeUnsafe` is\n   * sound only when every statement in between rides the SAME pooled\n   * connection, so a pure `BEGIN` checks one out, raw statements ride it, and\n   * the matching `COMMIT`/`ROLLBACK` releases it (same semantics as the pg and\n   * bun adapters). The ORM path (`execute`) and `transaction()` stay on the\n   * pool. Concurrent raw transactions on one adapter are unsupported.\n   */\n  let rawSession: MysqlConnectionLike | null = null;\n\n  function getPool(): MysqlPoolLike {\n    if (pool !== null) return pool;\n\n    if (options?.pool !== undefined) {\n      pool = options.pool;\n      ownsPool = false;\n      return pool;\n    }\n\n    const config: MysqlPoolConfig = {\n      uri: options?.url ?? process.env.MYSQL_URL,\n      host: options?.host,\n      port: options?.port,\n      user: options?.user,\n      password: options?.password,\n      database: options?.database,\n      connectionLimit: options?.connectionLimit,\n      charset: options?.charset,\n      timezone: options?.timezone ?? \"Z\",\n      decimalNumbers: false,\n      supportBigNumbers: true,\n      bigNumberStrings: true,\n      dateStrings: false,\n      jsonStrings: false,\n      namedPlaceholders: false,\n      multipleStatements: options?.multipleStatements ?? false,\n    };\n    pool = (options?.createPool ?? defaultCreatePool)(config);\n    ownsPool = true;\n    return pool;\n  }\n\n  async function runExecute(params: {\n    queryable: Queryable;\n    text: string;\n    values: unknown[];\n  }): Promise<Record<string, unknown>[]> {\n    const [result] = await runMapped(() => params.queryable.execute(params.text, params.values));\n    return normalizeDriverResult({ result }).rows;\n  }\n\n  async function runExecuteUnsafe(params: {\n    queryable: Queryable;\n    text: string;\n    values?: unknown[];\n  }): Promise<QueryResult> {\n    const [result] = await runMapped(() => params.queryable.query(params.text, params.values));\n    return normalizeDriverResult({ result });\n  }\n\n  /**\n   * Adapter bound to the ONE pinned connection of an open transaction — the\n   * same-connection guarantee. Nested `transaction()` calls open savepoints on\n   * that connection, naming them from the counter shared across the whole\n   * top-level transaction so siblings never collide.\n   */\n  function createConnectionAdapter(params: {\n    conn: MysqlConnectionLike;\n    savepointCounter: SavepointCounter;\n  }): DatabaseAdapter {\n    const { conn, savepointCounter } = params;\n\n    return {\n      dialect: DIALECT,\n      provider: PROVIDER,\n      wire: WIRE,\n\n      async execute(execParams) {\n        return runExecute({ queryable: conn, ...execParams });\n      },\n\n      async executeUnsafe(execParams) {\n        return runExecuteUnsafe({ queryable: conn, ...execParams });\n      },\n\n      async transaction<T>(\n        fn: (txAdapter: DatabaseAdapter) => Promise<T>,\n        nestedOptions?: TransactionOptions,\n      ): Promise<T> {\n        refuseNestedTransactionOptions({ options: nestedOptions, provider: PROVIDER });\n        const savepoint = nextSavepointName({ counter: savepointCounter });\n        await runMapped(() => conn.query(`SAVEPOINT ${savepoint}`));\n        try {\n          const result = await fn(createConnectionAdapter({ conn, savepointCounter }));\n          await runMapped(() => conn.query(`RELEASE SAVEPOINT ${savepoint}`));\n          return result;\n        } catch (error) {\n          // Best effort: never mask the original failure with a rollback failure.\n          try {\n            await conn.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);\n          } catch {\n            /* rollback is best-effort */\n          }\n          throw error;\n        }\n      },\n\n      async connect(): Promise<void> {\n        // Already connected — this adapter is bound to a pinned connection.\n      },\n\n      async disconnect(): Promise<void> {\n        // The pool owns the connection lifecycle; releasing happens at the\n        // top-level transaction boundary.\n      },\n\n      formatArrayParam(values: unknown[]): unknown {\n        return throwOnArrayParam(values);\n      },\n    };\n  }\n\n  return {\n    dialect: DIALECT,\n    provider: PROVIDER,\n    wire: WIRE,\n\n    async execute(params) {\n      return runExecute({ queryable: getPool(), ...params });\n    },\n\n    async executeUnsafe(params) {\n      const control = classifyRawTransactionControl({ text: params.text });\n      if (rawSession !== null) {\n        if (control === \"close\") {\n          const session = rawSession;\n          rawSession = null;\n          try {\n            return await runExecuteUnsafe({ queryable: session, ...params });\n          } finally {\n            session.release();\n          }\n        }\n        return runExecuteUnsafe({ queryable: rawSession, ...params });\n      }\n      if (control === \"open\") {\n        const conn = await runMapped(() => getPool().getConnection());\n        try {\n          const result = await runExecuteUnsafe({ queryable: conn, ...params });\n          rawSession = conn;\n          return result;\n        } catch (error) {\n          conn.release();\n          throw error;\n        }\n      }\n      return runExecuteUnsafe({ queryable: getPool(), ...params });\n    },\n\n    async transaction<T>(\n      fn: (txAdapter: DatabaseAdapter) => Promise<T>,\n      transactionOptions?: TransactionOptions,\n    ): Promise<T> {\n      // Validate the timeout before taking a connection, so a bad option fails\n      // fast instead of wasting a checkout.\n      const timeoutText =\n        transactionOptions?.timeout === undefined\n          ? undefined\n          : maxExecutionTimeStatement({ timeout: transactionOptions.timeout });\n\n      const conn = await runMapped(() => getPool().getConnection());\n      try {\n        // Session-scoped SELECT bound — see transaction-sql.ts for the loud\n        // \"SELECT statements only\" caveat. Reset in finally below.\n        if (timeoutText !== undefined) {\n          await runMapped(() => conn.query(timeoutText));\n        }\n        // Applies to the NEXT transaction in the session → must precede begin.\n        const isolationLevel = transactionOptions?.isolationLevel;\n        if (isolationLevel !== undefined) {\n          const isolationText = setIsolationLevelStatement({ isolationLevel });\n          await runMapped(() => conn.query(isolationText));\n        }\n        await runMapped(() => conn.beginTransaction());\n        try {\n          const result = await fn(createConnectionAdapter({ conn, savepointCounter: createSavepointCounter() }));\n          await runMapped(() => conn.commit());\n          return result;\n        } catch (error) {\n          // Best effort: never mask the original failure with a rollback failure.\n          try {\n            await conn.rollback();\n          } catch {\n            /* rollback is best-effort */\n          }\n          throw error;\n        }\n      } finally {\n        let poisoned = false;\n        if (timeoutText !== undefined) {\n          try {\n            await conn.query(RESET_MAX_EXECUTION_TIME_SQL);\n          } catch {\n            poisoned = true;\n          }\n        }\n        // A connection whose session default could not be restored must never\n        // return to the pool with a lowered MAX_EXECUTION_TIME.\n        if (poisoned) {\n          conn.destroy();\n        } else {\n          conn.release();\n        }\n      }\n    },\n\n    async connect(): Promise<void> {\n      const conn = await runMapped(() => getPool().getConnection());\n      try {\n        await runMapped(() => conn.ping());\n      } finally {\n        conn.release();\n      }\n    },\n\n    async disconnect(): Promise<void> {\n      if (rawSession !== null) {\n        // An abandoned raw transaction must not leak an in-transaction\n        // connection; roll it back best-effort before the pool ends.\n        const session = rawSession;\n        rawSession = null;\n        try {\n          await session.query(\"ROLLBACK\");\n        } catch {\n          /* the pool is closing; the session is going away regardless */\n        }\n        session.release();\n      }\n      if (pool !== null && ownsPool) {\n        const closing = pool;\n        pool = null;\n        await runMapped(() => closing.end());\n      }\n    },\n\n    formatArrayParam(values: unknown[]): unknown {\n      return throwOnArrayParam(values);\n    },\n  };\n}\n\n// ─── Re-exports (driver-error table, helpers) ─────────────────────\n\nexport {\n  MYSQL_ERRNO_ERROR_CODES,\n  MYSQL_ERRNO_REASONS,\n  mapMysqlDriverError,\n  mysqlErrorErrno,\n  runMapped,\n} from \"./errors.ts\";\nexport { isResultSetHeader, normalizeDriverResult } from \"./results.ts\";\nexport { createSavepointCounter, nextSavepointName } from \"./savepoints.ts\";\nexport type { SavepointCounter } from \"./savepoints.ts\";\nexport {\n  ISOLATION_LEVEL_SQL,\n  RESET_MAX_EXECUTION_TIME_SQL,\n  classifyRawTransactionControl,\n  maxExecutionTimeStatement,\n  refuseNestedTransactionOptions,\n  setIsolationLevelStatement,\n} from \"./transaction-sql.ts\";\nexport type { RawTransactionControl } from \"./transaction-sql.ts\";\n",
+    "/**\n * Driver-error mapping for mysql2.\n *\n * Constitution rule 5: a raw driver error never escapes an adapter. Every\n * failure becomes a `VibeError` with a stable code, the driver error attached\n * as `cause`, and the MySQL errno / symbolic code / SQLSTATE / server message\n * in `meta`.\n *\n * mysql2 errors carry `errno` (the numeric MySQL server error, e.g. 1062),\n * `code` (the symbolic name, `ER_DUP_ENTRY`, or a client-side string like\n * `ECONNREFUSED` / `PROTOCOL_CONNECTION_LOST`), `sqlState` and `sqlMessage`.\n * The table is keyed by `errno` because it is the stable server-side identity;\n * client-side failures have no errno and fall through to `VIBE_ADAPTER`.\n */\n\nimport { VibeError, type VibeErrorCode } from \"@vibeorm/schema\";\n\n// ─── Errno table ──────────────────────────────────────────────────\n\n/**\n * MySQL server errno → stable VibeError code. Frozen and mirrored by tests;\n * anything absent from this table maps to `VIBE_ADAPTER` — including access\n * failures (1044 `ER_DBACCESS_DENIED_ERROR`, 1045 `ER_ACCESS_DENIED_ERROR`)\n * and every client-side connection error (`ECONNREFUSED`,\n * `PROTOCOL_CONNECTION_LOST`, `ETIMEDOUT`), which carry no errno at all.\n */\nexport const MYSQL_ERRNO_ERROR_CODES: Readonly<Record<number, VibeErrorCode>> = Object.freeze({\n  /** ER_DUP_ENTRY */\n  1062: \"VIBE_UNIQUE_VIOLATION\",\n  /** ER_DUP_ENTRY_WITH_KEY_NAME */\n  1586: \"VIBE_UNIQUE_VIOLATION\",\n  /** ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO */\n  1761: \"VIBE_UNIQUE_VIOLATION\",\n  /** ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO */\n  1762: \"VIBE_UNIQUE_VIOLATION\",\n  /** ER_NO_REFERENCED_ROW */\n  1216: \"VIBE_FK_VIOLATION\",\n  /** ER_ROW_IS_REFERENCED */\n  1217: \"VIBE_FK_VIOLATION\",\n  /** ER_ROW_IS_REFERENCED_2 */\n  1451: \"VIBE_FK_VIOLATION\",\n  /** ER_NO_REFERENCED_ROW_2 */\n  1452: \"VIBE_FK_VIOLATION\",\n  /** ER_BAD_NULL_ERROR — NOT NULL column set to NULL */\n  1048: \"VIBE_VALIDATION\",\n  /** ER_WARN_DATA_OUT_OF_RANGE — value out of column range */\n  1264: \"VIBE_VALIDATION\",\n  /** ER_NO_DEFAULT_FOR_FIELD — column without default omitted */\n  1364: \"VIBE_VALIDATION\",\n  /** ER_DATA_TOO_LONG */\n  1406: \"VIBE_VALIDATION\",\n  /**\n   * WARN_DATA_TRUNCATED — despite the WARN_ name, strict mode raises it as a\n   * hard error: an out-of-range ENUM value or a truncated numeric string\n   * (live-verified on 8.4: `role = \"SUPERUSER\"` and `n = \"12abc\"` → 1265).\n   * The same bad input is a CHECK violation on sqlite and SQLSTATE 22P02 on\n   * postgres — all VIBE_VALIDATION (board #9).\n   */\n  1265: \"VIBE_VALIDATION\",\n  /**\n   * ER_TRUNCATED_WRONG_VALUE_FOR_FIELD — a wrong-TYPED value for the column\n   * (live-verified on 8.4: `\"abc\"` into INT, `\"12.x9\"` into DECIMAL → 1366).\n   */\n  1366: \"VIBE_VALIDATION\",\n  /**\n   * ER_TRUNCATED_WRONG_VALUE — an unparseable literal, e.g. a bad datetime\n   * (live-verified on 8.4: `\"not-a-date\"` into DATETIME(3) → 1292,\n   * SQLSTATE 22007).\n   */\n  1292: \"VIBE_VALIDATION\",\n  /** ER_CHECK_CONSTRAINT_VIOLATED */\n  3819: \"VIBE_VALIDATION\",\n  /** ER_LOCK_DEADLOCK */\n  1213: \"VIBE_TRANSACTION\",\n  /** ER_LOCK_WAIT_TIMEOUT */\n  1205: \"VIBE_TRANSACTION\",\n  /** ER_QUERY_TIMEOUT — max_execution_time exceeded, statement interrupted */\n  3024: \"VIBE_TRANSACTION\",\n});\n\n/** Errnos that additionally explain themselves through `meta.reason`. */\nexport const MYSQL_ERRNO_REASONS: Readonly<Record<number, string>> = Object.freeze({\n  /** ER_LOCK_DEADLOCK */\n  1213: \"deadlock\",\n  /** ER_LOCK_WAIT_TIMEOUT */\n  1205: \"timeout\",\n  /** ER_QUERY_TIMEOUT */\n  3024: \"timeout\",\n});\n\n// ─── Reading driver errors ────────────────────────────────────────\n\nfunction readStringField(params: { source: Record<string, unknown>; key: string }): string | undefined {\n  const value = params.source[params.key];\n  return typeof value === \"string\" && value.length > 0 ? value : undefined;\n}\n\n/**\n * Extract the numeric MySQL errno from a mysql2 error. Client-side failures\n * (`ECONNREFUSED`, `PROTOCOL_CONNECTION_LOST`, …) have no numeric errno and\n * yield `undefined`.\n */\nexport function mysqlErrorErrno(params: { error: unknown }): number | undefined {\n  const { error } = params;\n  if (error === null || typeof error !== \"object\") return undefined;\n  const errno = (error as Record<string, unknown>).errno;\n  return typeof errno === \"number\" && Number.isInteger(errno) ? errno : undefined;\n}\n\n// ─── Mapping ──────────────────────────────────────────────────────\n\n/**\n * Map any error thrown by mysql2 onto a `VibeError`.\n *\n * A `VibeError` passes through unchanged, so an error raised deeper inside the\n * ORM (or by a nested adapter call) is never re-wrapped, and a user callback's\n * error is rethrown identically.\n */\nexport function mapMysqlDriverError(params: { error: unknown }): VibeError {\n  const { error } = params;\n  if (error instanceof VibeError) return error;\n\n  const source: Record<string, unknown> =\n    error !== null && typeof error === \"object\" ? (error as Record<string, unknown>) : {};\n  const errno = mysqlErrorErrno({ error });\n  const code: VibeErrorCode =\n    (errno === undefined ? undefined : MYSQL_ERRNO_ERROR_CODES[errno]) ?? \"VIBE_ADAPTER\";\n\n  const meta: Record<string, unknown> = {};\n  if (errno !== undefined) meta.errno = errno;\n  const symbolicCode = readStringField({ source, key: \"code\" });\n  if (symbolicCode !== undefined) meta.code = symbolicCode;\n  const sqlState = readStringField({ source, key: \"sqlState\" });\n  if (sqlState !== undefined) meta.sqlState = sqlState;\n  const sqlMessage = readStringField({ source, key: \"sqlMessage\" });\n  if (sqlMessage !== undefined) meta.sqlMessage = sqlMessage.trim();\n  const reason = errno === undefined ? undefined : MYSQL_ERRNO_REASONS[errno];\n  if (reason !== undefined) meta.reason = reason;\n\n  const message =\n    readStringField({ source, key: \"message\" }) ??\n    (sqlMessage !== undefined ? sqlMessage.trim() : undefined) ??\n    (typeof error === \"string\" ? error : \"unknown mysql driver error\");\n\n  return new VibeError({ code, message, meta, cause: error });\n}\n\n/** Run a driver call, mapping anything it throws onto a `VibeError`. */\nexport async function runMapped<T>(fn: () => Promise<T>): Promise<T> {\n  try {\n    return await fn();\n  } catch (error) {\n    throw mapMysqlDriverError({ error });\n  }\n}\n",
+    "/**\n * Result normalization for mysql2.\n *\n * mysql2 resolves `execute()` / `query()` with a `[result, fields]` tuple where\n * `result` is one of:\n * - `RowDataPacket[]` — a SELECT's rows (plain objects; `rowsAsArray` is off);\n * - `ResultSetHeader` — an INSERT / UPDATE / DELETE / DDL OK-packet carrying\n *   `affectedRows` and `insertId`;\n * - an array of the above — only when `multipleStatements` is enabled, one\n *   entry per statement.\n *\n * The adapter's contract: `execute` returns rows (a header normalizes to `[]`);\n * `executeUnsafe` returns `{ rows, affectedRows }` (a SELECT has\n * `affectedRows: 0`, a mutation has `rows: []`). With `multipleStatements`\n * enabled the LAST statement's result wins, mirroring adapter-pglite's `exec`.\n */\n\nimport type { QueryResult } from \"@vibeorm/runtime\";\n\n// ─── Header detection ─────────────────────────────────────────────\n\n/**\n * True when a driver result value is shaped like mysql2's `ResultSetHeader`\n * (an OK-packet). Checks `affectedRows` + `serverStatus` together so a row\n * object that merely aliases a column as `affectedRows` is not misread.\n */\nexport function isResultSetHeader(params: { value: unknown }): boolean {\n  const { value } = params;\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) return false;\n  const source = value as Record<string, unknown>;\n  return typeof source.affectedRows === \"number\" && typeof source.serverStatus === \"number\";\n}\n\n// ─── Normalization ────────────────────────────────────────────────\n\n/** One result set (never a multi-statement array) → the adapter contract. */\nfunction normalizeSingle(value: unknown): QueryResult {\n  if (Array.isArray(value)) {\n    return { rows: value as Record<string, unknown>[], affectedRows: 0 };\n  }\n  if (isResultSetHeader({ value })) {\n    return { rows: [], affectedRows: (value as { affectedRows: number }).affectedRows };\n  }\n  return { rows: [], affectedRows: 0 };\n}\n\n/**\n * Normalize the first element of mysql2's `[result, fields]` tuple. A\n * multi-statement result (array whose last entry is itself a result set or an\n * OK-packet) collapses to its LAST statement's result.\n */\nexport function normalizeDriverResult(params: { result: unknown }): QueryResult {\n  const { result } = params;\n  if (Array.isArray(result)) {\n    const last: unknown = result.at(-1);\n    if (last !== undefined && (Array.isArray(last) || isResultSetHeader({ value: last }))) {\n      return normalizeSingle(last);\n    }\n    // A plain result set: row objects (or an empty SELECT).\n    return { rows: result as Record<string, unknown>[], affectedRows: 0 };\n  }\n  return normalizeSingle(result);\n}\n",
+    "/**\n * Savepoint naming for nested transactions.\n *\n * v1 lesson (LEARNINGS.md): the counter is shared **by reference** across every\n * adapter created for one top-level transaction, so sibling and deeply nested\n * savepoints can never collide on a name.\n */\n\n/** Mutable counter shared by reference across one top-level transaction. */\nexport type SavepointCounter = { n: number };\n\n/** Fresh counter — one per top-level transaction. */\nexport function createSavepointCounter(): SavepointCounter {\n  return { n: 0 };\n}\n\n/**\n * Allocate the next savepoint name (`vibeorm_sp_0`, `vibeorm_sp_1`, …) and\n * advance the shared counter. The name is an identifier by construction, so it\n * is safe to interpolate into `SAVEPOINT` / `RELEASE` / `ROLLBACK TO` SQL.\n */\nexport function nextSavepointName(params: { counter: SavepointCounter }): string {\n  return `vibeorm_sp_${params.counter.n++}`;\n}\n",
+    "/**\n * Transaction-control SQL text (mysql dialect).\n *\n * Kept apart from the adapter so the mapping from `TransactionOptions` to SQL\n * is unit-testable without a server, and so the timeout value is validated\n * before it is ever interpolated into a statement.\n *\n * MySQL specifics:\n * - `SET TRANSACTION ISOLATION LEVEL <level>` applies to the NEXT transaction\n *   started in the session, so the adapter issues it BEFORE\n *   `conn.beginTransaction()` — never inside the open transaction.\n * - MySQL has no general per-transaction statement timeout.\n *   `MAX_EXECUTION_TIME` is the closest tool and it bounds **SELECT statements\n *   only** — see {@link maxExecutionTimeStatement}.\n */\n\nimport type { IsolationLevel, TransactionOptions } from \"@vibeorm/runtime\";\nimport { VibeError } from \"@vibeorm/schema\";\n\n/** VibeORM isolation level → MySQL isolation level keyword. */\nexport const ISOLATION_LEVEL_SQL: Readonly<Record<IsolationLevel, string>> = Object.freeze({\n  ReadCommitted: \"READ COMMITTED\",\n  RepeatableRead: \"REPEATABLE READ\",\n  Serializable: \"SERIALIZABLE\",\n});\n\n/**\n * `SET TRANSACTION ISOLATION LEVEL <level>` — scoped to the next transaction\n * in the session, which is why the adapter sends it before\n * `conn.beginTransaction()` on the pinned connection.\n *\n * Observability trap (verified live on MySQL 8.4): the one-shot value IS\n * applied to the next transaction — `performance_schema.\n * events_transactions_current` reports the requested level — but\n * `@@transaction_isolation` NEVER reflects it; that variable keeps answering\n * the session value both before and inside the transaction. Tests must assert\n * the level's behavior (e.g. SERIALIZABLE turning plain SELECTs into locking\n * reads), not the variable — see tests/live.test.ts.\n */\nexport function setIsolationLevelStatement(params: { isolationLevel: IsolationLevel }): string {\n  return `SET TRANSACTION ISOLATION LEVEL ${ISOLATION_LEVEL_SQL[params.isolationLevel]}`;\n}\n\n/**\n * `SET SESSION MAX_EXECUTION_TIME = <ms>` — the closest MySQL gets to a\n * transaction timeout, and the semantics differ LOUDLY from postgres:\n *\n * **`MAX_EXECUTION_TIME` bounds SELECT statements only.** INSERT / UPDATE /\n * DELETE / DDL inside the transaction run unbounded; MySQL simply has no\n * per-statement timeout for mutations. An over-long SELECT is interrupted with\n * errno 3024 (`ER_QUERY_TIMEOUT`), mapped to `VIBE_TRANSACTION` with\n * `meta.reason = \"timeout\"`. The setting is session-scoped (not\n * transaction-scoped), so the adapter resets it to DEFAULT in `finally` before\n * the connection returns to the pool.\n *\n * One more caveat (verified live on MySQL 8.4): `SELECT SLEEP(n)` cannot\n * observe the bound — an interrupted `SLEEP()` swallows the kill and returns\n * `1` with NO error, so the statement comes back \"successfully\" at ~timeout.\n * Only a SELECT doing real work is cancelled with errno 3024.\n *\n * @throws VibeError `VIBE_VALIDATION` when the timeout is not a non-negative\n * integer — the value is interpolated into SQL, so it is never trusted blindly.\n */\nexport function maxExecutionTimeStatement(params: { timeout: number }): string {\n  const { timeout } = params;\n  if (!Number.isInteger(timeout) || timeout < 0) {\n    throw new VibeError({\n      code: \"VIBE_VALIDATION\",\n      message: `transaction timeout must be a non-negative integer of milliseconds, received ${String(timeout)}`,\n      meta: { timeout },\n    });\n  }\n  return `SET SESSION MAX_EXECUTION_TIME = ${timeout}`;\n}\n\n/**\n * Restores the session default after a transaction that set a timeout. Issued\n * in `finally`; if it fails the adapter destroys the connection instead of\n * releasing it, so a poisoned session never returns to the pool.\n */\nexport const RESET_MAX_EXECUTION_TIME_SQL: string = \"SET SESSION MAX_EXECUTION_TIME = DEFAULT\";\n\n// ─── Raw transaction control (session affinity) ─────────────────\n\n/** How a raw statement steers the adapter's session-affine raw transaction. */\nexport type RawTransactionControl = \"open\" | \"close\" | null;\n\nconst RAW_OPEN_PATTERN: RegExp = /^\\s*(?:begin|start\\s+transaction)\\b[^;]*;?\\s*$/i;\nconst RAW_CLOSE_PATTERN: RegExp = /^\\s*(?:commit|rollback)(?:\\s+work)?\\s*;?\\s*$/i;\n\n/**\n * Classify a raw statement as transaction control. A raw `BEGIN` … `COMMIT`\n * sequence over `executeUnsafe` is sound only when every statement in between\n * rides the SAME pooled connection, so the adapter pins one connection for\n * the whole raw transaction (\"open\" checks out, \"close\" releases). MySQL DDL\n * auto-commits, so @vibeorm/migrate never wraps here — this exists for raw\n * user sequences and keeps the three pool adapters' semantics identical.\n *\n * Deliberately strict: only PURE single-statement control text matches.\n * Compound scripts, `ROLLBACK TO SAVEPOINT` and `COMMIT AND CHAIN` (which\n * keeps a transaction open) never engage the pinning.\n */\nexport function classifyRawTransactionControl(params: { text: string }): RawTransactionControl {\n  if (RAW_OPEN_PATTERN.test(params.text)) return \"open\";\n  if (RAW_CLOSE_PATTERN.test(params.text)) return \"close\";\n  return null;\n}\n\n// ─── Nested transaction options (the cross-adapter contract) ──────\n\n/**\n * Refuse options on a NESTED `transaction()` call — the same contract on every\n * adapter (see the `DatabaseAdapter.transaction` JSDoc in @vibeorm/runtime):\n * a nested transaction is a SAVEPOINT, and a savepoint can neither change the\n * isolation level of the transaction it joins nor enforce its own timeout.\n * Silently dropping the option (the pre-#3 behaviour) hid exactly that.\n *\n * @throws VibeError `VIBE_VALIDATION` when `isolationLevel` or `timeout` is\n * present (an `undefined` or empty options object is accepted).\n */\nexport function refuseNestedTransactionOptions(params: {\n  options?: TransactionOptions;\n  provider: string;\n}): void {\n  const { options, provider } = params;\n  if (options === undefined) return;\n\n  const passed: string[] = [];\n  if (options.isolationLevel !== undefined) passed.push(\"isolationLevel\");\n  if (options.timeout !== undefined) passed.push(\"timeout\");\n  if (passed.length === 0) return;\n\n  const meta: Record<string, unknown> = { provider, nested: true };\n  if (options.isolationLevel !== undefined) meta.isolationLevel = options.isolationLevel;\n  if (options.timeout !== undefined) meta.timeout = options.timeout;\n\n  throw new VibeError({\n    code: \"VIBE_VALIDATION\",\n    message: `nested transactions run as savepoints and cannot honor ${passed.join(\" or \")} — a savepoint cannot change the isolation level of the transaction it joins, and a nested timeout is not enforceable; pass options on the top-level $transaction`,\n    meta,\n  });\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "81C757629DAE03DB64756E2164756E21",
+  "names": []
+}

package/dist/results.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Result normalization for mysql2.
+ *
+ * mysql2 resolves `execute()` / `query()` with a `[result, fields]` tuple where
+ * `result` is one of:
+ * - `RowDataPacket[]` — a SELECT's rows (plain objects; `rowsAsArray` is off);
+ * - `ResultSetHeader` — an INSERT / UPDATE / DELETE / DDL OK-packet carrying
+ *   `affectedRows` and `insertId`;
+ * - an array of the above — only when `multipleStatements` is enabled, one
+ *   entry per statement.
+ *
+ * The adapter's contract: `execute` returns rows (a header normalizes to `[]`);
+ * `executeUnsafe` returns `{ rows, affectedRows }` (a SELECT has
+ * `affectedRows: 0`, a mutation has `rows: []`). With `multipleStatements`
+ * enabled the LAST statement's result wins, mirroring adapter-pglite's `exec`.
+ */
+import type { QueryResult } from "@vibeorm/runtime";
+/**
+ * True when a driver result value is shaped like mysql2's `ResultSetHeader`
+ * (an OK-packet). Checks `affectedRows` + `serverStatus` together so a row
+ * object that merely aliases a column as `affectedRows` is not misread.
+ */
+export declare function isResultSetHeader(params: {
+    value: unknown;
+}): boolean;
+/**
+ * Normalize the first element of mysql2's `[result, fields]` tuple. A
+ * multi-statement result (array whose last entry is itself a result set or an
+ * OK-packet) collapses to its LAST statement's result.
+ */
+export declare function normalizeDriverResult(params: {
+    result: unknown;
+}): QueryResult;
+//# sourceMappingURL=results.d.ts.map

package/dist/results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"results.d.ts","sourceRoot":"","sources":["../src/results.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAIpD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAKrE;AAeD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GAAG,WAAW,CAW9E"}

package/dist/savepoints.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Savepoint naming for nested transactions.
+ *
+ * v1 lesson (LEARNINGS.md): the counter is shared **by reference** across every
+ * adapter created for one top-level transaction, so sibling and deeply nested
+ * savepoints can never collide on a name.
+ */
+/** Mutable counter shared by reference across one top-level transaction. */
+export type SavepointCounter = {
+    n: number;
+};
+/** Fresh counter — one per top-level transaction. */
+export declare function createSavepointCounter(): SavepointCounter;
+/**
+ * Allocate the next savepoint name (`vibeorm_sp_0`, `vibeorm_sp_1`, …) and
+ * advance the shared counter. The name is an identifier by construction, so it
+ * is safe to interpolate into `SAVEPOINT` / `RELEASE` / `ROLLBACK TO` SQL.
+ */
+export declare function nextSavepointName(params: {
+    counter: SavepointCounter;
+}): string;
+//# sourceMappingURL=savepoints.d.ts.map

package/dist/savepoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"savepoints.d.ts","sourceRoot":"","sources":["../src/savepoints.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,4EAA4E;AAC5E,MAAM,MAAM,gBAAgB,GAAG;IAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7C,qDAAqD;AACrD,wBAAgB,sBAAsB,IAAI,gBAAgB,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,gBAAgB,CAAA;CAAE,GAAG,MAAM,CAE/E"}

package/dist/transaction-sql.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Transaction-control SQL text (mysql dialect).
+ *
+ * Kept apart from the adapter so the mapping from `TransactionOptions` to SQL
+ * is unit-testable without a server, and so the timeout value is validated
+ * before it is ever interpolated into a statement.
+ *
+ * MySQL specifics:
+ * - `SET TRANSACTION ISOLATION LEVEL <level>` applies to the NEXT transaction
+ *   started in the session, so the adapter issues it BEFORE
+ *   `conn.beginTransaction()` — never inside the open transaction.
+ * - MySQL has no general per-transaction statement timeout.
+ *   `MAX_EXECUTION_TIME` is the closest tool and it bounds **SELECT statements
+ *   only** — see {@link maxExecutionTimeStatement}.
+ */
+import type { IsolationLevel, TransactionOptions } from "@vibeorm/runtime";
+/** VibeORM isolation level → MySQL isolation level keyword. */
+export declare const ISOLATION_LEVEL_SQL: Readonly<Record<IsolationLevel, string>>;
+/**
+ * `SET TRANSACTION ISOLATION LEVEL <level>` — scoped to the next transaction
+ * in the session, which is why the adapter sends it before
+ * `conn.beginTransaction()` on the pinned connection.
+ *
+ * Observability trap (verified live on MySQL 8.4): the one-shot value IS
+ * applied to the next transaction — `performance_schema.
+ * events_transactions_current` reports the requested level — but
+ * `@@transaction_isolation` NEVER reflects it; that variable keeps answering
+ * the session value both before and inside the transaction. Tests must assert
+ * the level's behavior (e.g. SERIALIZABLE turning plain SELECTs into locking
+ * reads), not the variable — see tests/live.test.ts.
+ */
+export declare function setIsolationLevelStatement(params: {
+    isolationLevel: IsolationLevel;
+}): string;
+/**
+ * `SET SESSION MAX_EXECUTION_TIME = <ms>` — the closest MySQL gets to a
+ * transaction timeout, and the semantics differ LOUDLY from postgres:
+ *
+ * **`MAX_EXECUTION_TIME` bounds SELECT statements only.** INSERT / UPDATE /
+ * DELETE / DDL inside the transaction run unbounded; MySQL simply has no
+ * per-statement timeout for mutations. An over-long SELECT is interrupted with
+ * errno 3024 (`ER_QUERY_TIMEOUT`), mapped to `VIBE_TRANSACTION` with
+ * `meta.reason = "timeout"`. The setting is session-scoped (not
+ * transaction-scoped), so the adapter resets it to DEFAULT in `finally` before
+ * the connection returns to the pool.
+ *
+ * One more caveat (verified live on MySQL 8.4): `SELECT SLEEP(n)` cannot
+ * observe the bound — an interrupted `SLEEP()` swallows the kill and returns
+ * `1` with NO error, so the statement comes back "successfully" at ~timeout.
+ * Only a SELECT doing real work is cancelled with errno 3024.
+ *
+ * @throws VibeError `VIBE_VALIDATION` when the timeout is not a non-negative
+ * integer — the value is interpolated into SQL, so it is never trusted blindly.
+ */
+export declare function maxExecutionTimeStatement(params: {
+    timeout: number;
+}): string;
+/**
+ * Restores the session default after a transaction that set a timeout. Issued
+ * in `finally`; if it fails the adapter destroys the connection instead of
+ * releasing it, so a poisoned session never returns to the pool.
+ */
+export declare const RESET_MAX_EXECUTION_TIME_SQL: string;
+/** How a raw statement steers the adapter's session-affine raw transaction. */
+export type RawTransactionControl = "open" | "close" | null;
+/**
+ * Classify a raw statement as transaction control. A raw `BEGIN` … `COMMIT`
+ * sequence over `executeUnsafe` is sound only when every statement in between
+ * rides the SAME pooled connection, so the adapter pins one connection for
+ * the whole raw transaction ("open" checks out, "close" releases). MySQL DDL
+ * auto-commits, so @vibeorm/migrate never wraps here — this exists for raw
+ * user sequences and keeps the three pool adapters' semantics identical.
+ *
+ * Deliberately strict: only PURE single-statement control text matches.
+ * Compound scripts, `ROLLBACK TO SAVEPOINT` and `COMMIT AND CHAIN` (which
+ * keeps a transaction open) never engage the pinning.
+ */
+export declare function classifyRawTransactionControl(params: {
+    text: string;
+}): RawTransactionControl;
+/**
+ * Refuse options on a NESTED `transaction()` call — the same contract on every
+ * adapter (see the `DatabaseAdapter.transaction` JSDoc in @vibeorm/runtime):
+ * a nested transaction is a SAVEPOINT, and a savepoint can neither change the
+ * isolation level of the transaction it joins nor enforce its own timeout.
+ * Silently dropping the option (the pre-#3 behaviour) hid exactly that.
+ *
+ * @throws VibeError `VIBE_VALIDATION` when `isolationLevel` or `timeout` is
+ * present (an `undefined` or empty options object is accepted).
+ */
+export declare function refuseNestedTransactionOptions(params: {
+    options?: TransactionOptions;
+    provider: string;
+}): void;
+//# sourceMappingURL=transaction-sql.d.ts.map

package/dist/transaction-sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-sql.d.ts","sourceRoot":"","sources":["../src/transaction-sql.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAG3E,+DAA+D;AAC/D,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAIvE,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE;IAAE,cAAc,EAAE,cAAc,CAAA;CAAE,GAAG,MAAM,CAE7F;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAU7E;AAED;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,EAAE,MAAmD,CAAC;AAI/F,+EAA+E;AAC/E,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAK5D;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,qBAAqB,CAI7F;AAID;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACrD,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,IAAI,CAkBP"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@vibeorm/adapter-mysql",
+  "version": "2.0.0-alpha.1",
+  "description": "mysql2 adapter for VibeORM v2",
+  "keywords": [
+    "orm",
+    "typescript",
+    "sql",
+    "database",
+    "bun",
+    "type-safe",
+    "mysql",
+    "mysql2",
+    "mariadb",
+    "adapter",
+    "driver"
+  ],
+  "homepage": "https://github.com/vibeorm/vibeorm/tree/master/packages/adapter-mysql#readme",
+  "bugs": {
+    "url": "https://github.com/vibeorm/vibeorm/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vibeorm/vibeorm.git",
+    "directory": "packages/adapter-mysql"
+  },
+  "license": "MIT",
+  "author": "VibeORM contributors",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "bun": ">=1.2.0"
+  },
+  "dependencies": {
+    "@vibeorm/runtime": "2.0.0-alpha.1",
+    "@vibeorm/schema": "2.0.0-alpha.1",
+    "mysql2": "^3.15.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}