@vibeorm/adapter-bun 1.3.0 → 2.0.0-alpha.2

package/dist/params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../src/params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAWH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,MAAM,CAmBnE;AAID;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,SAAS,OAAO,EAAE,CAAA;CAAE,GAAG,OAAO,EAAE,CAEjF;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,SAAS,OAAO,EAAE,CAAA;CAAE,GAAG,OAAO,EAAE,CAEpF"}

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/template-cache.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Synthetic tagged-template cache — bun:sql's prepared-statement path.
+ *
+ * bun:sql only creates a *named* prepared statement (one PostgreSQL keeps a
+ * plan for) when the query arrives as a tagged template. Generated SQL is a
+ * plain string, so with `preparedStatements: true` the adapter turns each SQL
+ * text into a synthetic `TemplateStringsArray` — split on the `$1`, `$2`, …
+ * placeholders — and reuses that same object identity for every execution.
+ *
+ * The cache is LRU-bounded so a long-running process never grows it without
+ * limit.
+ */
+/** LRU map from SQL text to the synthetic template used to execute it. */
+export type TemplateCache = {
+    /** Template for `text`, creating one on first sight. Stable by identity. */
+    getTemplate(params: {
+        text: string;
+    }): TemplateStringsArray;
+    /** Number of texts currently held — diagnostics and tests. */
+    size(): number;
+};
+/** Split a SQL text on `$n` placeholders into the literal chunks around them. */
+export declare function templateChunks(params: {
+    text: string;
+}): string[];
+/**
+ * Create a template cache holding at most `max` texts (least recently used
+ * evicted first).
+ */
+export declare function createTemplateCache(params: {
+    max: number;
+}): TemplateCache;
+//# sourceMappingURL=template-cache.d.ts.map

package/dist/template-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-cache.d.ts","sourceRoot":"","sources":["../src/template-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,0EAA0E;AAC1E,MAAM,MAAM,aAAa,GAAG;IAC1B,4EAA4E;IAC5E,WAAW,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,oBAAoB,CAAC;IAC5D,8DAA8D;IAC9D,IAAI,IAAI,MAAM,CAAC;CAChB,CAAC;AAEF,iFAAiF;AACjF,wBAAgB,cAAc,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,EAAE,CAEjE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CA4B1E"}

package/dist/transaction-sql.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Transaction-control SQL text (postgres dialect, bun:sql flavour).
+ *
+ * Used by the reserved-connection path, which issues `BEGIN` itself so that
+ * isolation level and statement timeout can be applied — bun:sql's
+ * `sql.begin(fn)` fast path takes no such options.
+ */
+import type { IsolationLevel, TransactionOptions } from "@vibeorm/runtime";
+/** VibeORM isolation level → PostgreSQL isolation level keyword. */
+export declare const ISOLATION_LEVEL_SQL: Readonly<Record<IsolationLevel, string>>;
+/** `BEGIN`, with an `ISOLATION LEVEL` clause when the caller asked for one. */
+export declare function beginStatement(params: {
+    isolationLevel?: IsolationLevel;
+}): string;
+/**
+ * `SET LOCAL statement_timeout = <ms>` — transaction-scoped, so PostgreSQL
+ * cancels an over-long statement with SQLSTATE 57014 (mapped to
+ * `VIBE_TRANSACTION` with `meta.reason = "timeout"`).
+ *
+ * @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 statementTimeoutStatement(params: {
+    timeout: number;
+}): 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.
+ *
+ * @vibeorm/migrate drives transactional DDL by sending literal `BEGIN` /
+ * `COMMIT` / `ROLLBACK` through its stateless `SqlExecutor` — sound only when
+ * every statement in between rides the SAME connection. The adapter uses this
+ * to pin one connection for the whole raw transaction ("open" reserves,
+ * "close" releases). On a pooled bun:sql instance an unpinned `BEGIN` is
+ * refused outright by the driver (`ERR_POSTGRES_UNSAFE_TRANSACTION`); other
+ * pool drivers would only work by checkout luck.
+ *
+ * Deliberately strict: only PURE single-statement control text matches
+ * (`BEGIN`, `BEGIN ISOLATION LEVEL …;`, `COMMIT`, `ROLLBACK WORK`, `END`,
+ * `ABORT`). Compound scripts, `ROLLBACK TO SAVEPOINT`, two-phase
+ * `COMMIT PREPARED` 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;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAG3E,oEAAoE;AACpE,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAIvE,CAAC;AAEH,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,MAAM,EAAE;IAAE,cAAc,CAAC,EAAE,cAAc,CAAA;CAAE,GAAG,MAAM,CAKlF;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAU7E;AAID,+EAA+E;AAC/E,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAK5D;;;;;;;;;;;;;;;;GAgBG;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

@@ -1,39 +1,48 @@
 {
   "name": "@vibeorm/adapter-bun",
-  "version": "1.3.0",
-  "description": "Bun-native database adapter for VibeORM using bun:sql",
-  "license": "MIT",
+  "version": "2.0.0-alpha.2",
+  "description": "bun:sql (Postgres) adapter for VibeORM v2",
   "keywords": [
     "orm",
-    "adapter",
+    "typescript",
+    "sql",
+    "database",
     "bun",
+    "type-safe",
+    "postgres",
     "postgresql",
-    "typescript"
+    "bun-sql",
+    "adapter",
+    "driver"
   ],
-  "type": "module",
-  "exports": {
-    ".": {
-      "default": "./src/index.ts",
-      "types": "./src/index.ts"
-    }
+  "homepage": "https://github.com/vibeorm/vibeorm/tree/master/packages/adapter-bun#readme",
+  "bugs": {
+    "url": "https://github.com/vibeorm/vibeorm/issues"
   },
-  "files": [
-    "src"
-  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/vibeorm/vibeorm.git",
     "directory": "packages/adapter-bun"
   },
-  "homepage": "https://github.com/vibeorm/vibeorm/tree/master/packages/adapter-bun",
-  "bugs": {
-    "url": "https://github.com/vibeorm/vibeorm/issues"
+  "license": "MIT",
+  "author": "VibeORM contributors",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "engines": {
-    "bun": ">=1.1.0"
+    "bun": ">=1.2.0"
   },
   "dependencies": {
-    "@vibeorm/runtime": "1.3.0"
+    "@vibeorm/runtime": "2.0.0-alpha.2",
+    "@vibeorm/schema": "2.0.0-alpha.2"
   },
   "publishConfig": {
     "access": "public"