@vibeorm/runtime 1.3.0 → 2.0.0-alpha.10

package/README.md

@@ -1,141 +1,84 @@
 # @vibeorm/runtime
 
-Driver-agnostic query engine and client runtime for VibeORM. This package contains the SQL query builder, WHERE clause compiler, relation loading strategies, and client factory. It does **not** include any database driver — use an adapter package to connect to PostgreSQL.
+> 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.
 
-## Installation
+The query engine behind the generated client: it turns delegate calls into SQL statements, loads relations, runs nested writes and moves values across the wire through the codec table. It is its own package because it is driver-agnostic — it talks to databases only through the `DatabaseAdapter` contract, so adapters and the generator can depend on it without depending on each other.
 
 ```bash
-bun add @vibeorm/runtime
+bun add @vibeorm/runtime@alpha
 ```
 
-You also need an adapter:
+> **Pre-release.** `2.0.0-alpha.x`, published under the `alpha` dist-tag. `npm i vibeorm` still resolves to the stable v1 line.
 
-```bash
-bun add @vibeorm/adapter-bun    # for bun:sql
-# or
-bun add @vibeorm/adapter-pg pg  # for node-postgres
-```
+Most users never install this directly — it ships as a dependency of [`vibeorm`](https://www.npmjs.com/package/vibeorm) and of the generated client. Reach for it when you are writing an adapter or tooling against the runtime.
 
-## Usage
+## What it does
 
-This package is consumed by the generated client. You typically don't import from it directly — the generated `index.ts` calls `createClient()` internally.
+`createClient({ schema, adapter, options })` builds a `DynamicClient` from the Schema IR at runtime: model delegates keyed by both camelCase client name and model name (`$models`), plus `$transaction`, `$queryRaw`, `$executeRaw`, `$queryRawUnsafe`, `$executeRawUnsafe`, `$on`, `$connect` and `$disconnect`. The delegates are deliberately broad here (`ClientRow` in, `ClientRow` out); the generated `.d.ts` declares the precise per-model types on top.
 
-```ts
-// The generated client wires everything together:
-import { VibeClient } from "./generated/vibeorm/index.ts";
-
-const db = VibeClient({
-  relationStrategy: "query",
-  log: false,
-});
-```
+Each `ModelDelegate` implements 16 methods:
 
-## API
+| Group | Methods |
+|---|---|
+| Read | `findMany` · `findFirst` · `findFirstOrThrow` · `findUnique` · `findUniqueOrThrow` |
+| Create | `create` · `createMany` · `createManyAndReturn` |
+| Update | `update` · `updateMany` · `upsert` |
+| Delete | `delete` · `deleteMany` |
+| Aggregate | `count` · `aggregate` · `groupBy` |
 
-### `createClient({ options, modelMeta, schemas? })`
+The statement-building pieces are exported too, for tooling that needs SQL without executing it: `buildQuery`, `compileWhere`, `compileSelect`, `compileOrderBy`, `resolveResultShape`, and the runtime metadata builders `buildRuntimeMeta`, `getModelMeta`, `getFieldMeta`.
 
-Creates a VibeORM client instance. Called by generated code — takes model metadata, optional Zod schemas, and client options.
+## The adapter contract
 
-`countStrategy` can be set globally in client options and overridden per count call:
+`DatabaseAdapter` is frozen. Implement it and any driver works with the whole ORM:
 
 ```ts
-await db.user.count({
-  where: { isActive: true },
-  countStrategy: "subquery",
-});
+import type { DatabaseAdapter, QueryResult, TransactionOptions } from "@vibeorm/runtime";
+
+const adapter: DatabaseAdapter = {
+  dialect: "postgres",
+  provider: "postgresql",
+  async execute(params: { text: string; values: unknown[] }): Promise<Record<string, unknown>[]> { /* … */ },
+  async executeUnsafe(params: { text: string; values?: unknown[] }): Promise<QueryResult> { /* … */ },
+  async transaction<T>(fn: (tx: DatabaseAdapter) => Promise<T>, options?: TransactionOptions): Promise<T> { /* … */ },
+  async connect(): Promise<void> { /* … */ },
+  async disconnect(): Promise<void> { /* … */ },
+  formatArrayParam(values: unknown[]): unknown { /* … */ },
+};
 ```
 
-Per-operation `countStrategy` takes precedence over the client default.
-
-### Mutation RETURNING behavior
-
-`create`, `update`, `delete`, and `upsert` now narrow SQL `RETURNING` columns when `select` is provided, reducing row payload size.
-
-- Default behavior: full scalar row is returned (same as before)
-- With `select`: only selected scalar columns are returned (plus internal keys when needed)
-- With `returning: true`: force full scalar `RETURNING` payload even when `select` is present
+- `execute` is the ORM hot path (row-returning, statement-cached by the adapter). `executeUnsafe` is the raw/DDL path and is the only place `affectedRows` surfaces.
+- `transaction` nests: an inner call creates a savepoint. `isolationLevel` and `timeout` are top-level only — a nested call must refuse both with `VIBE_VALIDATION`.
+- Adapters never let raw driver errors escape. Each maps its driver's failures to `VibeError` codes (`VIBE_UNIQUE_VIOLATION`, `VIBE_FK_VIOLATION`, `VIBE_TRANSACTION`, `VIBE_ADAPTER`) through a per-driver table, with the driver error as `cause`.
+- `formatArrayParam` converts a JS array into the driver's preferred scalar-array representation; the ORM path binds arrays through it, the raw path does not.
+- The optional `wire` declaration (`WireFidelity`) tells the runtime what the driver already delivers for non-list scalars, so provably no-op decoders can be skipped.
 
-### `toSqlExecutor({ adapter })`
+`toSqlExecutor({ adapter })` bridges an adapter to the `SqlExecutor` shape `@vibeorm/migrate` runs on.
 
-Bridges a `DatabaseAdapter` to a `SqlExecutor` for use with the migrate package.
-
-### `withRetry(fn, options?)`
-
-Retry utility with exponential backoff and jitter. Only retries `VibeTransientError` instances (connection failures, deadlocks, serialization conflicts, statement timeouts, pool exhaustion). Deterministic errors (`VibeRequestError`) are never retried.
+## Relation strategies
 
 ```ts
-import { withRetry } from "@vibeorm/runtime";
-
-// Basic — 3 retries, exponential backoff with jitter
-const users = await withRetry(() =>
-  db.user.findMany({ where: { active: true } })
-);
-
-// Custom options
-const user = await withRetry(
-  () => db.user.create({ data: { email: "new@example.com" } }),
-  { maxRetries: 5, baseDelay: 100, maxDelay: 10000 },
-);
-
-// Retry only specific error codes
-const result = await withRetry(
-  () => db.$transaction(async (tx) => {
-    /* ... */
-  }, { isolationLevel: "Serializable" }),
-  { retryOn: ["SERIALIZATION_FAILURE", "DEADLOCK"] },
-);
-
-// With abort signal
-const controller = new AbortController();
-const result = await withRetry(
-  () => db.user.findFirst({ where: { id: 1 } }),
-  { signal: controller.signal },
-);
+const db = createClient({ schema, adapter, options: { relationStrategy: "join" } });
 ```
 
-**Options (`RetryOptions`):**
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `maxRetries` | `3` | Max retry attempts (total executions = maxRetries + 1) |
-| `baseDelay` | `50` | Base delay in ms for exponential backoff |
-| `maxDelay` | `5000` | Maximum delay cap in ms |
-| `maxJitter` | `50` | Random jitter added per retry to prevent thundering herd |
-| `signal` | — | `AbortSignal` to cancel pending retries |
-| `retryOn` | — | Filter to retry only specific `VibeTransientErrorCode`s |
-| `onRetry` | — | Callback `({ error, attempt, delay }) => void` for logging/metrics |
-
-Backoff formula: `min(baseDelay * 2^attempt + random(0, maxJitter), maxDelay)`
-
-### `VibeValidationError`
+- `"query"` (default): one query per relation, batched with `WHERE ... IN`. Works on every dialect.
+- `"join"`: a single statement using `LEFT JOIN LATERAL` with JSON aggregation. PostgreSQL and PGlite only; other dialects throw `VibeError` with code `VIBE_UNSUPPORTED_CAPABILITY`.
 
-Custom error class thrown when Zod validation fails on input or output data.
+A `relationStrategy` argument on a find overrides the client default. Relation trees are resolved by `resolveRelationSelection` / `resolveRelationLink` and attached by `attachRelations` (query strategy) or `attachLateralRelations` (join strategy).
 
-### `DatabaseAdapter` interface
+## Codecs
 
-The contract that adapter packages implement:
+Value encoding and decoding lives in one table per dialect: `POSTGRES_CODECS`, `SQLITE_CODECS`, `MYSQL_CODECS`, indexed by `DIALECT_CODECS` and reachable through `getCodec({ dialect, type })`. Nothing else in the codebase coerces values — scattered coercion is what produced v1's BigInt, enum-array and timestamp bugs.
 
 ```ts
-type DatabaseAdapter = {
-  execute(params: { text: string; values: unknown[] }): Promise<Record<string, unknown>[]>;
-  executeRaw(params: { text: string; values: unknown[] }): Promise<QueryResult>;
-  transaction<T>(params: { fn: (adapter: DatabaseAdapter) => Promise<T> }): Promise<T>;
-  connect(): Promise<void>;
-  disconnect(): Promise<void>;
-};
+import { decodeRows, encodeValue, getCodec } from "@vibeorm/runtime";
 ```
 
-### Relation Loading Strategies
-
-| Strategy | Method | Best for |
-|----------|--------|----------|
-| `"query"` | Parent query + batched `WHERE IN` queries | Deep/nested includes |
-| `"join"` | `LEFT JOIN LATERAL` + JSON aggregation | Flat includes, fewer round-trips |
-
-### Exported Types
-
-`DatabaseAdapter`, `QueryResult`, `SqlExecutor`, `VibeClientOptions`, `ModelMeta`, `ModelMetaMap`, `ModelSchemas`, `ValidationSchema`, `QueryProfile`, `RelationProfile`, `ScalarFieldMeta`, `RelationFieldMeta`, `SqlQuery`, `Operation`, `RetryOptions`.
+`encodeValue` runs on every parameter, `decodeValue` / `decodeRow` / `decodeRows` on every row materialization point — including relation children and join-strategy rows, not only top-level parents. `decodeAggregateValue` handles aggregate columns, whose result type differs from the underlying field's.
 
-## License
+## Links
 
-[MIT](../../LICENSE)
+- [Documentation](https://github.com/vibeorm/vibeorm/tree/master/docs)
+- [Query API](https://github.com/vibeorm/vibeorm/blob/master/docs/queries.md)
+- [Repository and issues](https://github.com/vibeorm/vibeorm)
+- MIT licensed

package/dist/adapter.d.ts

@@ -0,0 +1,250 @@
+/**
+ * Database adapter contract for VibeORM v2. FROZEN INTERFACE — the runtime is
+ * driver-agnostic and talks to databases exclusively through this type;
+ * adapter packages (adapter-bun, adapter-pg, adapter-pglite, adapter-sqlite,
+ * adapter-mysql) implement it.
+ *
+ * ERROR CONTRACT: adapters never let raw driver errors escape. Every failure
+ * is mapped to a VibeError with a stable code via a per-driver table
+ * (unique violation → VIBE_UNIQUE_VIOLATION, FK violation → VIBE_FK_VIOLATION,
+ * serialization/deadlock → VIBE_TRANSACTION, connection/other → VIBE_ADAPTER),
+ * with the driver error attached as `cause`.
+ */
+import type { Dialect, Provider } from "@vibeorm/schema";
+import type { WireFidelity } from "@vibeorm/sql";
+/** Transaction isolation levels (mapped per dialect by the adapter). */
+export type IsolationLevel = "ReadCommitted" | "RepeatableRead" | "Serializable";
+/**
+ * What a caller REQUIRES of a transaction deadline (EPIC 6).
+ *
+ * - `"between-statements"` (the default, deliverable by every adapter): an
+ *   expired budget refuses the next statement, refuses the `COMMIT`, and rolls
+ *   back. A statement already in flight is NOT interrupted.
+ * - `"cancel-running-statements"`: additionally hands the engine the remaining
+ *   budget as `statement_timeout`, so the SERVER cancels an over-long
+ *   statement. Postgres servers only (`adapter-pg`, `adapter-bun`); every other
+ *   adapter refuses the request with `VIBE_UNSUPPORTED_CAPABILITY` rather than
+ *   quietly delivering the weaker level.
+ */
+export type TransactionDeadlineEnforcement = "between-statements" | "cancel-running-statements";
+/**
+ * A TOTAL wall-clock budget for one top-level transaction (EPIC 6) — distinct
+ * from {@link TransactionOptions.timeout}, which bounds a single statement.
+ *
+ * The clock starts immediately before `BEGIN` is sent, so acquiring a
+ * connection (bounded separately by the pooled adapters' own acquire timeout)
+ * is NOT counted against it.
+ *
+ * On expiry the adapter refuses the next statement, refuses the commit and
+ * rolls back, and every handle of that transaction becomes unusable. Nothing
+ * is retried automatically: a callback's external side effects (an SMS, a
+ * payment, a queued job) may already have happened. JavaScript cannot forcibly
+ * stop a running callback — it can only refuse its later database calls.
+ */
+export type TransactionDeadline = {
+    /** Whole milliseconds, greater than zero. */
+    readonly totalMs: number;
+    /** Defaults to `"between-statements"`. */
+    readonly enforcement?: TransactionDeadlineEnforcement;
+};
+/**
+ * Options for `$transaction` / `adapter.transaction`.
+ *
+ * `timeout` is milliseconds, enforced database-side where the engine can
+ * genuinely cancel a running statement (postgres servers via `SET LOCAL
+ * statement_timeout`, mysql's SELECT-only `MAX_EXECUTION_TIME`). Dialect
+ * honesty: an adapter whose engine CANNOT enforce it refuses loudly instead
+ * of no-opping — sqlite adapters throw `VIBE_VALIDATION` (busy_timeout only
+ * bounds lock acquisition), pglite throws `VIBE_UNSUPPORTED_CAPABILITY` (the
+ * WASM build accepts statement_timeout but never fires it). Its meaning is
+ * UNCHANGED by the deadline work below: it is a PER-STATEMENT bound.
+ *
+ * `deadline` is the TOTAL budget for the whole transaction — see
+ * {@link TransactionDeadline}.
+ *
+ * Options are TOP-LEVEL only: a nested `transaction()` call (a savepoint)
+ * refuses ALL THREE fields with `VIBE_VALIDATION` on every adapter — a
+ * savepoint cannot change the isolation level of the transaction it joins,
+ * a nested timeout is not enforceable, and a nested deadline would need an
+ * independent session setting on a connection it does not own. A nested
+ * savepoint instead INHERITS the top-level deadline, by reference.
+ */
+export type TransactionOptions = {
+    isolationLevel?: IsolationLevel;
+    timeout?: number;
+    deadline?: TransactionDeadline;
+};
+/**
+ * How far an engine's per-statement timeout actually reaches.
+ *
+ * Tri-state rather than boolean because MySQL's `MAX_EXECUTION_TIME` bounds
+ * **SELECT statements only** — INSERT/UPDATE/DELETE run unbounded there, so
+ * declaring `true` would be exactly the silent misbehaviour constitution rule 4
+ * forbids.
+ */
+export type StatementTimeoutSupport = "all-statements" | "select-only" | "unsupported";
+/** The strongest transaction-deadline guarantee an adapter can honestly deliver. */
+export type TransactionDeadlineSupport = "cancel-running-statements" | "between-statements" | "unsupported";
+/**
+ * What timing budgets this adapter genuinely enforces (EPIC 6). Read it to
+ * decide what to ask for; the adapter refuses anything beyond it rather than
+ * degrading silently.
+ */
+export type AdapterBudgetSupport = {
+    /**
+     * The wait for a pooled connection is bounded. False on the single-connection
+     * engines (pglite, both sqlite adapters), which have no pool to exhaust.
+     */
+    readonly acquireTimeout: boolean;
+    /** What `TransactionOptions.timeout` reaches on this engine. */
+    readonly statementTimeout: StatementTimeoutSupport;
+    /** What `TransactionOptions.deadline.enforcement` may ask for on this engine. */
+    readonly transactionDeadline: TransactionDeadlineSupport;
+};
+/** Result of an unsafe/raw execution: rows plus affected-row count. */
+export type QueryResult = {
+    rows: Record<string, unknown>[];
+    affectedRows: number;
+};
+/**
+ * The primary interface every database adapter implements. Adapters own
+ * connection management, statement caching, transactions (including nested →
+ * savepoints), driver-specific parameter formatting and driver-error mapping.
+ */
+export type DatabaseAdapter = {
+    /** SQL dialect this adapter's database speaks (selects the @vibeorm/sql dialect). */
+    readonly dialect: Dialect;
+    /** Concrete provider (pglite and postgresql both speak `postgres`). */
+    readonly provider: Provider;
+    /**
+     * What this DRIVER actually delivers for non-list scalar columns on the
+     * result path (board #30) — lets the runtime's decode plans skip decoders
+     * that are provably no-ops for this driver (e.g. node-postgres already hands
+     * `Date` for timestamptz and parsed values for jsonb). OPTIONAL and purely
+     * an optimization contract: an adapter that declares nothing gets the full
+     * idempotency-guarded decode path. Declare only what the driver verifiably
+     * does; transactional adapters must carry the same declaration.
+     */
+    readonly wire?: WireFidelity;
+    /**
+     * Execute a parameterized query on the ORM hot path and return rows.
+     * The adapter owns prepared-statement caching and ORM-path parameter
+     * serialization (e.g. tagged scalar-list params vs JSON values).
+     */
+    execute(params: {
+        text: string;
+        values: unknown[];
+    }): Promise<Record<string, unknown>[]>;
+    /**
+     * Execute a raw query (`$queryRaw*`, `$executeRaw*`, DDL). No statement
+     * caching; raw-path parameter serialization (arrays pass through to the
+     * driver where it supports them — see LEARNINGS: raw vs ORM paths differ).
+     *
+     * OMITTING `values` changes semantics on the sqlite adapters (board #31):
+     * `adapter-sqlite` and `adapter-better-sqlite3` route no-`values` text
+     * through the driver's multi-statement script mode (`db.run`/`exec` — the
+     * shape @vibeorm/migrate emits for DDL/PRAGMA batches), which CANNOT return
+     * rows: a parameterless SELECT yields `rows: []` there, while pg/pglite/
+     * mysql/bun return its result set either way. Callers that want rows from a
+     * single parameterless statement must pass `values: []` — the client's
+     * `$queryRawUnsafe` always does. Rule of thumb: `values` present (even
+     * empty) = one prepared statement with rows; `values` absent = script mode,
+     * rows not guaranteed.
+     */
+    executeUnsafe(params: {
+        text: string;
+        values?: unknown[];
+    }): Promise<QueryResult>;
+    /**
+     * ORM-path execution (same protocol and parameter serialization as
+     * {@link DatabaseAdapter.execute}) that ALSO reports the affected-row count.
+     *
+     * WHY IT EXISTS (F01): bulk mutations need a row count, and `executeUnsafe`
+     * used to be the only entry point that surfaces one — but `executeUnsafe` is
+     * the RAW path, and a driver is free to implement it with client-side text
+     * escaping. mysql2 does (`pool.query`), and client-side escaping cannot know
+     * the server's `sql_mode`: under `NO_BACKSLASH_ESCAPES` a hostile string
+     * predicate breaks out of its literal. Generated statements must never take
+     * that route, so the runtime prefers this entry point and only falls back to
+     * `executeUnsafe` for an adapter that does not implement it.
+     *
+     * OPTIONAL, so the frozen contract stays additive: an adapter whose raw path
+     * already binds parameters (pg, pglite, bun, both sqlite adapters) is equally
+     * safe without it. An implementation MUST bind — never interpolate, and never
+     * fall back to text interpolation when preparation fails.
+     */
+    executeAffected?(params: {
+        text: string;
+        values: unknown[];
+    }): Promise<QueryResult>;
+    /**
+     * What timing budgets this adapter actually enforces (EPIC 6).
+     *
+     * OPTIONAL, so the frozen contract stays additive — exactly like
+     * {@link DatabaseAdapter.executeAffected}. An adapter that declares nothing
+     * is treated as declaring nothing: callers must not infer support from a
+     * provider name. Every adapter in this repository declares it.
+     */
+    readonly budgets?: AdapterBudgetSupport;
+    /**
+     * Run `fn` inside a transaction; the callback receives a transactional
+     * adapter with this same interface. Nested calls create savepoints. Throwing
+     * rolls back (the savepoint or the whole transaction) and rethrows.
+     *
+     * `options` is honored on TOP-LEVEL calls only. A NESTED call refuses any
+     * `isolationLevel` or `timeout` with `VIBE_VALIDATION` (`meta.nested:
+     * true`), identically on every adapter: a savepoint cannot change the
+     * isolation level of the transaction it joins, and a nested timeout is not
+     * enforceable. Silently dropping the option was the pre-#3 behaviour of the
+     * pg/pglite/mysql/bun adapters and is forbidden by constitution rule 4.
+     */
+    transaction<T>(fn: (txAdapter: DatabaseAdapter) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    /** Eagerly open/verify connectivity (pool warm-up or first connection). */
+    connect(): Promise<void>;
+    /**
+     * Gracefully close the connections open right now. NOT terminal: every
+     * adapter constructs its pool/connection lazily, so a query issued after
+     * `disconnect()` transparently opens a NEW connection and succeeds — the
+     * documented contract (symmetric with lazy construction, and with Prisma's
+     * `$disconnect()`-then-query semantics), not an accident.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Convert a JS array into the driver's preferred representation for a
+     * scalar-array parameter (postgres `= ANY($n)`): PG array literal string for
+     * drivers that send strings, the raw array for drivers with native support.
+     */
+    formatArrayParam(values: unknown[]): unknown;
+};
+/** Minimal SQL execution interface used by @vibeorm/migrate. */
+export type SqlExecutor = (params: {
+    text: string;
+    values?: unknown[];
+}) => Promise<Record<string, unknown>[]>;
+/**
+ * Bridge a DatabaseAdapter to the migrate package's SqlExecutor shape.
+ *
+ * NO SESSION AFFINITY — this bridge pins nothing. Every call goes through
+ * `adapter.executeUnsafe`, which a pooled adapter runs on whatever connection
+ * the pool hands out. @vibeorm/migrate's executor contract requires the
+ * opposite (`packages/migrate/src/types.ts`): its session-scoped statements
+ * (`BEGIN`/`COMMIT`, `PRAGMA foreign_keys`, `pg_advisory_lock` / `GET_LOCK`)
+ * must all reach ONE session. pglite and sqlite satisfy that by construction;
+ * a POOLED adapter (pg, mysql, bun) used for migrate must be constructed with
+ * a single-connection pool (`max: 1`; mysql `connectionLimit: 1`), as the
+ * `vibeorm` CLI does, or the caller must pin a connection another way —
+ * otherwise the advisory lock is taken on one connection while each
+ * migration's `BEGIN` runs on another, and a driver that reaps the idle
+ * lock-holding connection (node-postgres does, after 10s by default) releases
+ * the migration lock mid-run, silently.
+ *
+ * RE-ENTRANCY HAZARD: `pg_advisory_lock` is re-entrant per SESSION, so two
+ * concurrent `applyMigrations` calls sharing one adapter (hence one pool) can
+ * both "acquire" it on the same underlying connection and get zero mutual
+ * exclusion — separate CLI processes never collide this way, a programmatic
+ * caller sharing one adapter can.
+ */
+export declare function toSqlExecutor(params: {
+    adapter: DatabaseAdapter;
+}): SqlExecutor;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

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