@vibeorm/adapter-pg 4.2.0 → 5.0.0

package/dist/pool-config.d.ts

@@ -47,12 +47,37 @@ export declare function placePlanCacheMode(params: {
     connectionString: string | undefined;
     planCacheMode: PlanCacheMode;
 }): StartupOptionsPlacement;
+/**
+ * Validate an `idleTimeout` option value (AW-04): integer milliseconds from
+ * 0 through 2,147,483,647. pg-pool passes it to `setTimeout`; larger values
+ * overflow Node's signed 32-bit timer range and become a 1 ms timeout.
+ *
+ * @throws VibeError `VIBE_CONFIG` (`meta.reason: "invalid-idle-timeout"`).
+ */
+export declare function assertIdleTimeout(params: {
+    value: unknown;
+}): number;
+/**
+ * Validate a `min` option value (V7): an integer from 0 through the pool's
+ * `max`. pg-pool never idle-closes a connection while the pool holds `min` or
+ * fewer; it does not open them in advance (`adapter.connect()` does).
+ *
+ * @throws VibeError `VIBE_CONFIG` (`meta.reason: "invalid-pool-min"`).
+ */
+export declare function assertPoolMin(params: {
+    value: unknown;
+    max: number;
+}): number;
 /** Build the `pg.Pool` constructor config for an adapter-owned pool. */
 export declare function buildPoolConfig(params: {
     connectionString: string | undefined;
     max: number;
+    /** Connections pg-pool keeps open however long they idle (pg-pool's `min`). Absent = pg-pool's 0. */
+    min?: number;
     statementTimeout?: number;
     connectionTimeout?: number;
+    /** Milliseconds an idle pooled connection stays open (pg-pool's `idleTimeoutMillis`; `0` = never closed). Absent = pg-pool's 10 000. */
+    idleTimeout?: number;
     planCacheMode?: PlanCacheMode;
 }): Record<string, unknown>;
 //# sourceMappingURL=pool-config.d.ts.map

package/dist/statement-cache.d.ts

@@ -20,12 +20,21 @@
  *    `max` per connection, permanently. Statements still bind their parameters;
  *    only the server-side plan cache is skipped.
  *
- * 2. **Adapters sharing one pool must not collide** (F18). Each adapter used to
+ * 2. **One name never means two texts** (F18, EPIC H). Each adapter used to
  *    start its own counter at zero, so two adapters on one pool both sent
  *    `vibeorm_0` for different SQL and postgres refused the second
- *    ("Prepared statements must be unique"). Names are therefore allocated by a
- *    registry shared per pool, which also stops N adapters from preparing the
- *    same text N times.
+ *    ("Prepared statements must be unique"). Worse, two INDEPENDENT registries
+ *    (two pools, two processes) whose sessions reach one backend — a pooler
+ *    that switches backends — could execute another registry's `vibeorm_0`
+ *    and return that statement's rows without any error. A name is therefore
+ *    derived from the text itself: `vibeorm_` + the SHA-256 of the exact
+ *    statement text, base32 (see {@link statementNameFor}). Equal names mean
+ *    equal texts in every registry, process and adapter version, so the worst
+ *    a foreign backend can do is refuse a name (26000/42P05), never run another
+ *    text under it. The registry is still shared per pool, which keeps one
+ *    budget per pool and stops N adapters from preparing the same text N times.
+ *    Only the text is hashed: node-postgres sends no parameter types with a
+ *    named Parse, and result parsers live on the client, not the backend.
  *
  * 3. **A one-off text must not spend the budget.** Because names never evict
  *    (property 1), allocating on FIRST sight hands the whole budget to whatever
@@ -38,6 +47,16 @@
  *    text or exceed the budget. A hot text loses exactly one prepared
  *    execution; a one-off text costs the server nothing.
  */
+/**
+ * The content-addressed prepared-statement name of `text`: `vibeorm_` + the
+ * SHA-256 of its UTF-8 bytes in lowercase base32 without padding — 52
+ * characters, 60 bytes in total, within PostgreSQL's 63-byte identifier limit
+ * (NAMEDATALEN − 1), so the server never truncates two names into one. The same
+ * text yields the same name in every registry, process and version.
+ */
+export declare function statementNameFor(params: {
+    text: string;
+}): string;
 /** Registry mapping SQL text to the prepared-statement name `pg` should send. */
 export type StatementNameCache = {
     /**
@@ -55,7 +74,7 @@ export type StatementNameCache = {
 };
 /**
  * Create a statement-name registry that allocates at most `max` names
- * (`vibeorm_0`, `vibeorm_1`, …), each on the `promoteAfter`-th sighting of its
+ * ({@link statementNameFor} of the text), each on the `promoteAfter`-th sighting of its
  * text (default 2). Texts seen fewer times, and texts arriving after the budget
  * is spent, get no name and run unprepared, so the server's prepared-statement
  * retention stays bounded and a stream of one-off texts cannot consume it.

package/dist/timestamp-text.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Char-code decoding of PostgreSQL's PLAIN timestamp wire text (performance
+ * round 3, AW-03).
+ *
+ * node-postgres hands every `timestamptz` cell to pg-types' parser
+ * (postgres-date: three regular expressions, `parseInt` per field, a split)
+ * and every `timestamp` cell to this adapter's `parseZoneLessAsUtc` (a regular
+ * expression, two `replace` calls and a template string before `new Date`).
+ * The text PostgreSQL prints for the common case has a fixed layout, so one
+ * pass over its character codes yields the same instant 2.5–3× cheaper.
+ *
+ * This function only ACCEPTS or DECLINES: it returns `undefined` for every
+ * text outside the plain form, and the caller then runs today's parser
+ * unchanged. It never adds a coercion of its own — an accepted text decodes
+ * to exactly the instant today's parser returns (differential test
+ * `tests/timestamp-text.test.ts`).
+ */
+/**
+ * Decode `YYYY-MM-DD HH:MM:SS[.f{1,6}]` — followed by `±HH` or `±HH:MM` when
+ * `zoned`, by nothing otherwise — as a `Date`: zone-less text is read as UTC
+ * wall-clock time, zoned text at its offset. Fraction digits beyond the third
+ * are truncated (as postgres-date and `parseZoneLessAsUtc` both do).
+ *
+ * Returns `undefined` — "use today's parser" — for anything else: years
+ * before 1000 (`Date.UTC` maps 0–99 to 1900–1999), BC dates, `infinity`,
+ * offsets with seconds (historic local mean time), date-only text, 7+
+ * fraction digits, and out-of-range fields (month 13, February 30, hour 24,
+ * second 60), so the fallback keeps every such text's current decoding.
+ */
+export declare function parsePlainTimestampText(params: {
+    readonly text: string;
+    readonly zoned: boolean;
+}): Date | undefined;
+//# sourceMappingURL=timestamp-text.d.ts.map

package/dist/transaction-sql.d.ts

@@ -66,5 +66,27 @@ export type RawTransactionControl = "open" | "close" | null;
 export declare function classifyRawTransactionControl(params: {
     text: string;
 }): RawTransactionControl;
+/**
+ * Whether raw text WITHOUT bound values is PROVABLY one statement whose result
+ * and errors are the same in the extended protocol (a one-Sync batch) as in the
+ * simple protocol node-postgres uses for it — so it may ride a batch behind
+ * pending control (`BEGIN`, `SAVEPOINT`) like any bound statement.
+ *
+ * The proof is lexical and conservative:
+ * - no `;` anywhere (PostgreSQL's grammar splits statements only on `;`, so a
+ *   non-blank text without one is ONE statement or a syntax error — the same
+ *   error in both protocols; a `;` inside a string literal is refused too);
+ * - no `$` (a `$1` without values fails with a different SQLSTATE in each
+ *   protocol; dollar quoting is refused with it);
+ * - no comment (`--`, `/*`) and not blank (an empty query has no statement);
+ * - not transaction control (`BEGIN`, `COMMIT`, `ROLLBACK`, `SAVEPOINT`,
+ *   `RELEASE`, `PREPARE TRANSACTION`, …) and not `COPY` (its stdin refusal
+ *   text differs inside a batch).
+ * Anything else keeps today's path: it goes alone, after its control was
+ * confirmed.
+ */
+export declare function isSingleStatementText(params: {
+    text: string;
+}): boolean;
 export { refuseNestedTransactionOptions } from "@vibeorm/runtime/adapter-kit";
 //# sourceMappingURL=transaction-sql.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeorm/adapter-pg",
-  "version": "4.2.0",
+  "version": "5.0.0",
   "description": "node-postgres adapter for VibeORM v2 — Bun or Node.js",
   "keywords": [
     "orm",
@@ -45,8 +45,8 @@
     "bun": ">=1.2.0"
   },
   "dependencies": {
-    "@vibeorm/runtime": "4.2.0",
-    "@vibeorm/schema": "4.2.0"
+    "@vibeorm/runtime": "5.0.0",
+    "@vibeorm/schema": "5.0.0"
   },
   "peerDependencies": {
     "pg": ">=8"