@relaybus/postgres 0.2.0 → 0.3.1

package/README.md

@@ -50,7 +50,9 @@ try {
 ```
 
 The transaction handle is a `pg` `PoolClient`. If you pass `connectionString` instead of `pool`, the store creates and,
-on `close()`, ends its own pool. A pool or executor you pass in is never closed by the store.
+on `close()`, ends its own pool. A pool or executor you pass in is never closed by the store. When `bus.stop()` runs past
+its deadline, the store destroys the connections it opened itself (its own pool's and the one it listens for
+notifications on), so a query stuck on a lock fails at once instead of holding the shutdown; your pool is left as is.
 
 ### Other libraries
 
@@ -78,6 +80,28 @@ await db.transaction().execute(async (trx) => {
 Use `transactionResolver` (for example from `@nestjs-cls/transactional`) to avoid passing the handle explicitly.
 For another client, implement `PostgresExecutor` (`transaction` and `query`; about 20 lines).
 
+**Transaction time budget.** `bus.transaction` passes the bus `transactionTimeout` (default `'5s'`) to the store,
+which sets it with `set_config(..., true)` (the `SET LOCAL` scope, gone after the transaction) as
+`statement_timeout`. Executors that declare `sessionTimeouts: true` (`PgExecutor` does; it listens for `error` on the
+connection while the transaction runs) also get `idle_in_transaction_session_timeout` and, on PostgreSQL 17+,
+`transaction_timeout`, so a transaction left idle by a slow external call is ended by the server and its locks are
+released. The other adapters keep only `statement_timeout`, because a server-ended session would emit an unhandled
+`error` on their checked-out `pg` connection; the bus still rolls back an overrun before the commit. The caller gets a
+`TransactionTimeoutError` with the server error as `cause`. `PgExecutor` sends the settings in the round trip of `BEGIN`
+(the optional executor method `transactionWithBudget`), so the budget costs no extra round trip; executors without it
+send them as the first statement of the transaction.
+
+Where the budget lives depends on who owns the pool:
+
+- **A pool the store created** (`connectionString`/`poolConfig`): each connection keeps the budget as a session setting.
+  The first `bus.transaction` on a connection sets it with `BEGIN`; later ones send nothing extra, so a publish costs
+  what it did without a budget. A transaction without a budget (setup, a transactional handler) puts the session
+  defaults back in its `BEGIN`. Statements outside a transaction (claims, completions) run under the budget the
+  connection last got. With `preparedStatements: false` (a pooler in transaction mode, which would carry session
+  settings to other clients) the budget stays transaction-scoped.
+- **A pool or executor you pass in**: the budget is transaction-scoped (`SET LOCAL` semantics), set with `BEGIN` by
+  `PgExecutor` and by its own statement for the other adapters. Session settings of your pool are never changed.
+
 **Prisma is not integration-tested yet.** The adapter is typed structurally (no Prisma dependency) and unit-tested
 against a fake client only. Prisma interactive transactions default to a 5 s timeout, so pass
 `createPrismaExecutor(prisma, { timeout, maxWait })` if handlers run longer.
@@ -97,7 +121,7 @@ against a fake client only. Prisma interactive transactions default to a 5 s tim
 | `wakeUp`                                 | `'notify'`            | `'notify'`: coalesced `NOTIFY` + `LISTEN` wake other processes. `'poll'`: no notifications, other processes poll.  |
 
 **Pool errors.** A pool created from `connectionString` gets an `error` listener that logs through `logger`
-(`[PostgresEventStore](constructor) Idle connection failed ...`); `pg` then replaces the dead connection, so a failover
+(`[PostgresEventStore](connect) Idle connection failed ...`); `pg` then replaces the dead connection, so a failover
 or `pg_terminate_backend` of an idle connection does not crash the process. A `pool` you pass in is yours: attach
 `pool.on('error', ...)` to it yourself, because without a listener `pg` re-throws the error as an uncaught exception.
 
@@ -139,6 +163,8 @@ same on every database. The tables are created with aggressive autovacuum settin
 
 ## Upgrading from 0.1.0
 
+The step-by-step guide, including `completionHistory` and PgBouncer settings, is [Upgrading from 0.1 to 0.2](https://berkcansavur.github.io/relaybus/upgrading).
+
 `setup()` upgrades a 0.1.0 schema in place, in one transaction under the same advisory lock, and is safe to run again:
 it adds `lane` to every delivery (hash of the key, or of the event id) and `handlers` to every event (from the
 existing deliveries), turns `processing` deliveries into `pending` (their attempt stays counted, as a lost lease would

package/dist/chunk-NNZJR5AB.js

@@ -0,0 +1,12 @@
+// src/adapter-executor.ts
+function adapterExecutor(client) {
+  return {
+    transaction: client.transaction,
+    // eslint-disable-next-line relaybus/max-two-params -- PostgresExecutor port signature
+    query: (sql, parameters, transaction) => client.run(transaction ?? client.root, { sql, parameters })
+  };
+}
+
+export { adapterExecutor };
+//# sourceMappingURL=chunk-NNZJR5AB.js.map
+//# sourceMappingURL=chunk-NNZJR5AB.js.map

package/dist/chunk-NNZJR5AB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapter-executor.ts"],"names":[],"mappings":";AAqBO,SAAS,gBACd,MAAA,EAC8B;AAC9B,EAAA,OAAO;AAAA,IACL,aAAa,MAAA,CAAO,WAAA;AAAA;AAAA,IAEpB,KAAA,EAAO,CAAC,GAAA,EAAK,UAAA,EAAY,WAAA,KACvB,MAAA,CAAO,GAAA,CAAI,WAAA,IAAe,MAAA,CAAO,IAAA,EAAM,EAAE,GAAA,EAAK,YAAY;AAAA,GAC9D;AACF","file":"chunk-NNZJR5AB.js","sourcesContent":["import type { PostgresExecutor, PostgresParameter, PostgresRow } from './executor.js';\n\n/** One statement the store sends, with its positional parameters. */\nexport type AdapterStatement = {\n  readonly sql: string;\n  readonly parameters: readonly PostgresParameter[];\n};\n\n/** What an adapter supplies: where statements run outside a transaction, and how it runs one. */\nexport type AdapterClient<TQueryable> = {\n  /** The instance itself: statements outside a transaction run on it. */\n  readonly root: TQueryable;\n  readonly transaction: PostgresExecutor<TQueryable>['transaction'];\n  /** Runs one statement on the caller's transaction, else on the root. */\n  readonly run: (queryable: TQueryable, statement: AdapterStatement) => Promise<PostgresRow[]>;\n};\n\n/**\n * The executor every library adapter shares: a statement runs on the transaction it is given,\n * else on the root instance. An adapter supplies only how its library runs one statement.\n */\nexport function adapterExecutor<TQueryable>(\n  client: AdapterClient<TQueryable>,\n): PostgresExecutor<TQueryable> {\n  return {\n    transaction: client.transaction,\n    // eslint-disable-next-line relaybus/max-two-params -- PostgresExecutor port signature\n    query: (sql, parameters, transaction) =>\n      client.run(transaction ?? client.root, { sql, parameters }),\n  };\n}\n"]}

package/dist/drizzle.cjs

@@ -2,7 +2,14 @@
 
 var drizzleOrm = require('drizzle-orm');
 
-// src/drizzle/drizzle-executor.ts
+// src/adapter-executor.ts
+function adapterExecutor(client) {
+  return {
+    transaction: client.transaction,
+    // eslint-disable-next-line relaybus/max-two-params -- PostgresExecutor port signature
+    query: (sql, parameters, transaction) => client.run(transaction ?? client.root, { sql, parameters })
+  };
+}
 
 // src/positional-sql.ts
 function splitPositionalSql(sql) {
@@ -18,16 +25,17 @@ function splitPositionalSql(sql) {
 
 // src/drizzle/drizzle-executor.ts
 function createDrizzleExecutor(database) {
-  return {
+  return adapterExecutor({
+    root: database,
     transaction: (work) => database.transaction(work),
-    async query(sql, parameters, transaction) {
+    async run(queryable, { sql, parameters }) {
       const chunks = splitPositionalSql(sql).map(
         (part) => typeof part === "string" ? drizzleOrm.sql.raw(part) : drizzleOrm.sql.param(parameters[part.parameterIndex])
       );
-      const result = await (transaction ?? database).execute(drizzleOrm.sql.join(chunks));
+      const result = await queryable.execute(drizzleOrm.sql.join(chunks));
       return result.rows;
     }
-  };
+  });
 }
 
 exports.createDrizzleExecutor = createDrizzleExecutor;

package/dist/drizzle.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/positional-sql.ts","../src/drizzle/drizzle-executor.ts"],"names":["drizzleSql"],"mappings":";;;;;;;AASO,SAAS,mBAAmB,GAAA,EAAkC;AACnE,EAAA,MAAM,QAA6B,EAAC;AACpC,EAAA,IAAI,SAAA,GAAY,CAAA;AAChB,EAAA,KAAA,MAAW,KAAA,IAAS,GAAA,CAAI,QAAA,CAAS,UAAU,CAAA,EAAG;AAC5C,IAAA,KAAA,CAAM,IAAA,CAAK,GAAA,CAAI,KAAA,CAAM,SAAA,EAAW,MAAM,KAAK,CAAA,EAAG,EAAE,cAAA,EAAgB,OAAO,KAAA,CAAM,CAAC,CAAC,CAAA,GAAI,GAAG,CAAA;AACtF,IAAA,SAAA,GAAY,KAAA,CAAM,KAAA,GAAQ,KAAA,CAAM,CAAC,CAAA,CAAE,MAAA;AAAA,EACrC;AACA,EAAA,KAAA,CAAM,IAAA,CAAK,GAAA,CAAI,KAAA,CAAM,SAAS,CAAC,CAAA;AAC/B,EAAA,OAAO,KAAA;AACT;;;ACAO,SAAS,sBAAsB,QAAA,EAA2D;AAC/F,EAAA,OAAO;AAAA,IACL,WAAA,EAAa,CAAC,IAAA,KAAS,QAAA,CAAS,YAAY,IAAI,CAAA;AAAA,IAChD,MAAM,KAAA,CAAM,GAAA,EAAK,UAAA,EAA0C,WAAA,EAAa;AACtE,MAAA,MAAM,MAAA,GAAS,kBAAA,CAAmB,GAAG,CAAA,CAAE,GAAA;AAAA,QAAI,CAAC,IAAA,KAC1C,OAAO,IAAA,KAAS,WACZA,cAAA,CAAW,GAAA,CAAI,IAAI,CAAA,GACnBA,cAAA,CAAW,KAAA,CAAM,UAAA,CAAW,IAAA,CAAK,cAAc,CAAC;AAAA,OACtD;AACA,MAAA,MAAM,MAAA,GAAS,OAAO,WAAA,IAAe,QAAA,EAAU,QAAQA,cAAA,CAAW,IAAA,CAAK,MAAM,CAAC,CAAA;AAC9E,MAAA,OAAO,MAAA,CAAO,IAAA;AAAA,IAChB;AAAA,GACF;AACF","file":"drizzle.cjs","sourcesContent":["/** A piece of SQL text, or a reference to the (zero-based) parameter that stands at this position. */\nexport type PositionalSqlPart = string | { readonly parameterIndex: number };\n\n/**\n * Splits SQL written with PostgreSQL `$1, $2, ...` placeholders into text and\n * parameter references, in order of appearance. A placeholder used twice\n * appears twice. Adapters for libraries with their own placeholder syntax\n * (Knex `?`, Drizzle parameter chunks) rebuild the statement from the parts.\n */\nexport function splitPositionalSql(sql: string): PositionalSqlPart[] {\n  const parts: PositionalSqlPart[] = [];\n  let textStart = 0;\n  for (const match of sql.matchAll(/\\$(\\d+)/g)) {\n    parts.push(sql.slice(textStart, match.index), { parameterIndex: Number(match[1]) - 1 });\n    textStart = match.index + match[0].length;\n  }\n  parts.push(sql.slice(textStart));\n  return parts;\n}\n","import { sql as drizzleSql, type SQL } from 'drizzle-orm';\nimport type { PostgresExecutor, PostgresParameter } from '../executor.js';\nimport { splitPositionalSql } from '../positional-sql.js';\n\n/** What a Drizzle database and a Drizzle transaction have in common. */\nexport interface DrizzleQueryable {\n  execute(query: SQL): PromiseLike<{ readonly rows: Record<string, unknown>[] }>;\n}\n\n/** The part of a Drizzle `node-postgres` database the executor uses. */\nexport interface DrizzleLike extends DrizzleQueryable {\n  transaction<T>(work: (transaction: DrizzleQueryable) => Promise<T>): Promise<T>;\n}\n\n/**\n * Executor for Drizzle with the `node-postgres` driver. The transaction handle\n * is a Drizzle transaction: pass `tx` from `db.transaction(async (tx) => ...)`.\n */\nexport function createDrizzleExecutor(database: DrizzleLike): PostgresExecutor<DrizzleQueryable> {\n  return {\n    transaction: (work) => database.transaction(work),\n    async query(sql, parameters: readonly PostgresParameter[], transaction) {\n      const chunks = splitPositionalSql(sql).map((part) =>\n        typeof part === 'string'\n          ? drizzleSql.raw(part)\n          : drizzleSql.param(parameters[part.parameterIndex]),\n      );\n      const result = await (transaction ?? database).execute(drizzleSql.join(chunks));\n      return result.rows;\n    },\n  };\n}\n"]}
+{"version":3,"sources":["../src/adapter-executor.ts","../src/positional-sql.ts","../src/drizzle/drizzle-executor.ts"],"names":["drizzleSql"],"mappings":";;;;;AAqBO,SAAS,gBACd,MAAA,EAC8B;AAC9B,EAAA,OAAO;AAAA,IACL,aAAa,MAAA,CAAO,WAAA;AAAA;AAAA,IAEpB,KAAA,EAAO,CAAC,GAAA,EAAK,UAAA,EAAY,WAAA,KACvB,MAAA,CAAO,GAAA,CAAI,WAAA,IAAe,MAAA,CAAO,IAAA,EAAM,EAAE,GAAA,EAAK,YAAY;AAAA,GAC9D;AACF;;;ACrBO,SAAS,mBAAmB,GAAA,EAAkC;AACnE,EAAA,MAAM,QAA6B,EAAC;AACpC,EAAA,IAAI,SAAA,GAAY,CAAA;AAChB,EAAA,KAAA,MAAW,KAAA,IAAS,GAAA,CAAI,QAAA,CAAS,UAAU,CAAA,EAAG;AAC5C,IAAA,KAAA,CAAM,IAAA,CAAK,GAAA,CAAI,KAAA,CAAM,SAAA,EAAW,MAAM,KAAK,CAAA,EAAG,EAAE,cAAA,EAAgB,OAAO,KAAA,CAAM,CAAC,CAAC,CAAA,GAAI,GAAG,CAAA;AACtF,IAAA,SAAA,GAAY,KAAA,CAAM,KAAA,GAAQ,KAAA,CAAM,CAAC,CAAA,CAAE,MAAA;AAAA,EACrC;AACA,EAAA,KAAA,CAAM,IAAA,CAAK,GAAA,CAAI,KAAA,CAAM,SAAS,CAAC,CAAA;AAC/B,EAAA,OAAO,KAAA;AACT;;;ACCO,SAAS,sBAAsB,QAAA,EAA2D;AAC/F,EAAA,OAAO,eAAA,CAAkC;AAAA,IACvC,IAAA,EAAM,QAAA;AAAA,IACN,WAAA,EAAa,CAAC,IAAA,KAAS,QAAA,CAAS,YAAY,IAAI,CAAA;AAAA,IAChD,MAAM,GAAA,CAAI,SAAA,EAAW,EAAE,GAAA,EAAK,YAAW,EAAG;AACxC,MAAA,MAAM,MAAA,GAAS,kBAAA,CAAmB,GAAG,CAAA,CAAE,GAAA;AAAA,QAAI,CAAC,IAAA,KAC1C,OAAO,IAAA,KAAS,WACZA,cAAA,CAAW,GAAA,CAAI,IAAI,CAAA,GACnBA,cAAA,CAAW,KAAA,CAAM,UAAA,CAAW,IAAA,CAAK,cAAc,CAAC;AAAA,OACtD;AACA,MAAA,MAAM,SAAS,MAAM,SAAA,CAAU,QAAQA,cAAA,CAAW,IAAA,CAAK,MAAM,CAAC,CAAA;AAC9D,MAAA,OAAO,MAAA,CAAO,IAAA;AAAA,IAChB;AAAA,GACD,CAAA;AACH","file":"drizzle.cjs","sourcesContent":["import type { PostgresExecutor, PostgresParameter, PostgresRow } from './executor.js';\n\n/** One statement the store sends, with its positional parameters. */\nexport type AdapterStatement = {\n  readonly sql: string;\n  readonly parameters: readonly PostgresParameter[];\n};\n\n/** What an adapter supplies: where statements run outside a transaction, and how it runs one. */\nexport type AdapterClient<TQueryable> = {\n  /** The instance itself: statements outside a transaction run on it. */\n  readonly root: TQueryable;\n  readonly transaction: PostgresExecutor<TQueryable>['transaction'];\n  /** Runs one statement on the caller's transaction, else on the root. */\n  readonly run: (queryable: TQueryable, statement: AdapterStatement) => Promise<PostgresRow[]>;\n};\n\n/**\n * The executor every library adapter shares: a statement runs on the transaction it is given,\n * else on the root instance. An adapter supplies only how its library runs one statement.\n */\nexport function adapterExecutor<TQueryable>(\n  client: AdapterClient<TQueryable>,\n): PostgresExecutor<TQueryable> {\n  return {\n    transaction: client.transaction,\n    // eslint-disable-next-line relaybus/max-two-params -- PostgresExecutor port signature\n    query: (sql, parameters, transaction) =>\n      client.run(transaction ?? client.root, { sql, parameters }),\n  };\n}\n","/** A piece of SQL text, or a reference to the (zero-based) parameter that stands at this position. */\nexport type PositionalSqlPart = string | { readonly parameterIndex: number };\n\n/**\n * Splits SQL written with PostgreSQL `$1, $2, ...` placeholders into text and\n * parameter references, in order of appearance. A placeholder used twice\n * appears twice. Adapters for libraries with their own placeholder syntax\n * (Knex `?`, Drizzle parameter chunks) rebuild the statement from the parts.\n */\nexport function splitPositionalSql(sql: string): PositionalSqlPart[] {\n  const parts: PositionalSqlPart[] = [];\n  let textStart = 0;\n  for (const match of sql.matchAll(/\\$(\\d+)/g)) {\n    parts.push(sql.slice(textStart, match.index), { parameterIndex: Number(match[1]) - 1 });\n    textStart = match.index + match[0].length;\n  }\n  parts.push(sql.slice(textStart));\n  return parts;\n}\n","import { adapterExecutor } from '../adapter-executor.js';\nimport { sql as drizzleSql, type SQL } from 'drizzle-orm';\nimport type { PostgresExecutor } from '../executor.js';\nimport { splitPositionalSql } from '../positional-sql.js';\n\n/** What a Drizzle database and a Drizzle transaction have in common. */\nexport interface DrizzleQueryable {\n  execute(query: SQL): PromiseLike<{ readonly rows: Record<string, unknown>[] }>;\n}\n\n/** The part of a Drizzle `node-postgres` database the executor uses. */\nexport interface DrizzleLike extends DrizzleQueryable {\n  transaction<T>(work: (transaction: DrizzleQueryable) => Promise<T>): Promise<T>;\n}\n\n/**\n * Executor for Drizzle with the `node-postgres` driver. The transaction handle\n * is a Drizzle transaction: pass `tx` from `db.transaction(async (tx) => ...)`.\n */\nexport function createDrizzleExecutor(database: DrizzleLike): PostgresExecutor<DrizzleQueryable> {\n  return adapterExecutor<DrizzleQueryable>({\n    root: database,\n    transaction: (work) => database.transaction(work),\n    async run(queryable, { sql, parameters }) {\n      const chunks = splitPositionalSql(sql).map((part) =>\n        typeof part === 'string'\n          ? drizzleSql.raw(part)\n          : drizzleSql.param(parameters[part.parameterIndex]),\n      );\n      const result = await queryable.execute(drizzleSql.join(chunks));\n      return result.rows;\n    },\n  });\n}\n"]}

package/dist/drizzle.d.cts

@@ -1,5 +1,5 @@
 import { SQL } from 'drizzle-orm';
-import { P as PostgresExecutor } from './executor-VZGmsMX4.cjs';
+import { P as PostgresExecutor } from './executor-CfJgktC6.cjs';
 
 /** What a Drizzle database and a Drizzle transaction have in common. */
 interface DrizzleQueryable {

package/dist/drizzle.d.ts

@@ -1,5 +1,5 @@
 import { SQL } from 'drizzle-orm';
-import { P as PostgresExecutor } from './executor-VZGmsMX4.js';
+import { P as PostgresExecutor } from './executor-CfJgktC6.js';
 
 /** What a Drizzle database and a Drizzle transaction have in common. */
 interface DrizzleQueryable {

package/dist/drizzle.js

@@ -1,17 +1,19 @@
 import { splitPositionalSql } from './chunk-UUFSUL2M.js';
+import { adapterExecutor } from './chunk-NNZJR5AB.js';
 import { sql } from 'drizzle-orm';
 
 function createDrizzleExecutor(database) {
-  return {
+  return adapterExecutor({
+    root: database,
     transaction: (work) => database.transaction(work),
-    async query(sql$1, parameters, transaction) {
+    async run(queryable, { sql: sql$1, parameters }) {
       const chunks = splitPositionalSql(sql$1).map(
         (part) => typeof part === "string" ? sql.raw(part) : sql.param(parameters[part.parameterIndex])
       );
-      const result = await (transaction ?? database).execute(sql.join(chunks));
+      const result = await queryable.execute(sql.join(chunks));
       return result.rows;
     }
-  };
+  });
 }
 
 export { createDrizzleExecutor };

package/dist/drizzle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/drizzle/drizzle-executor.ts"],"names":["sql","drizzleSql"],"mappings":";;;AAkBO,SAAS,sBAAsB,QAAA,EAA2D;AAC/F,EAAA,OAAO;AAAA,IACL,WAAA,EAAa,CAAC,IAAA,KAAS,QAAA,CAAS,YAAY,IAAI,CAAA;AAAA,IAChD,MAAM,KAAA,CAAMA,KAAA,EAAK,UAAA,EAA0C,WAAA,EAAa;AACtE,MAAA,MAAM,MAAA,GAAS,kBAAA,CAAmBA,KAAG,CAAA,CAAE,GAAA;AAAA,QAAI,CAAC,IAAA,KAC1C,OAAO,IAAA,KAAS,WACZC,GAAA,CAAW,GAAA,CAAI,IAAI,CAAA,GACnBA,GAAA,CAAW,KAAA,CAAM,UAAA,CAAW,IAAA,CAAK,cAAc,CAAC;AAAA,OACtD;AACA,MAAA,MAAM,MAAA,GAAS,OAAO,WAAA,IAAe,QAAA,EAAU,QAAQA,GAAA,CAAW,IAAA,CAAK,MAAM,CAAC,CAAA;AAC9E,MAAA,OAAO,MAAA,CAAO,IAAA;AAAA,IAChB;AAAA,GACF;AACF","file":"drizzle.js","sourcesContent":["import { sql as drizzleSql, type SQL } from 'drizzle-orm';\nimport type { PostgresExecutor, PostgresParameter } from '../executor.js';\nimport { splitPositionalSql } from '../positional-sql.js';\n\n/** What a Drizzle database and a Drizzle transaction have in common. */\nexport interface DrizzleQueryable {\n  execute(query: SQL): PromiseLike<{ readonly rows: Record<string, unknown>[] }>;\n}\n\n/** The part of a Drizzle `node-postgres` database the executor uses. */\nexport interface DrizzleLike extends DrizzleQueryable {\n  transaction<T>(work: (transaction: DrizzleQueryable) => Promise<T>): Promise<T>;\n}\n\n/**\n * Executor for Drizzle with the `node-postgres` driver. The transaction handle\n * is a Drizzle transaction: pass `tx` from `db.transaction(async (tx) => ...)`.\n */\nexport function createDrizzleExecutor(database: DrizzleLike): PostgresExecutor<DrizzleQueryable> {\n  return {\n    transaction: (work) => database.transaction(work),\n    async query(sql, parameters: readonly PostgresParameter[], transaction) {\n      const chunks = splitPositionalSql(sql).map((part) =>\n        typeof part === 'string'\n          ? drizzleSql.raw(part)\n          : drizzleSql.param(parameters[part.parameterIndex]),\n      );\n      const result = await (transaction ?? database).execute(drizzleSql.join(chunks));\n      return result.rows;\n    },\n  };\n}\n"]}
+{"version":3,"sources":["../src/drizzle/drizzle-executor.ts"],"names":["sql","drizzleSql"],"mappings":";;;;AAmBO,SAAS,sBAAsB,QAAA,EAA2D;AAC/F,EAAA,OAAO,eAAA,CAAkC;AAAA,IACvC,IAAA,EAAM,QAAA;AAAA,IACN,WAAA,EAAa,CAAC,IAAA,KAAS,QAAA,CAAS,YAAY,IAAI,CAAA;AAAA,IAChD,MAAM,GAAA,CAAI,SAAA,EAAW,OAAEA,KAAA,EAAK,YAAW,EAAG;AACxC,MAAA,MAAM,MAAA,GAAS,kBAAA,CAAmBA,KAAG,CAAA,CAAE,GAAA;AAAA,QAAI,CAAC,IAAA,KAC1C,OAAO,IAAA,KAAS,WACZC,GAAA,CAAW,GAAA,CAAI,IAAI,CAAA,GACnBA,GAAA,CAAW,KAAA,CAAM,UAAA,CAAW,IAAA,CAAK,cAAc,CAAC;AAAA,OACtD;AACA,MAAA,MAAM,SAAS,MAAM,SAAA,CAAU,QAAQA,GAAA,CAAW,IAAA,CAAK,MAAM,CAAC,CAAA;AAC9D,MAAA,OAAO,MAAA,CAAO,IAAA;AAAA,IAChB;AAAA,GACD,CAAA;AACH","file":"drizzle.js","sourcesContent":["import { adapterExecutor } from '../adapter-executor.js';\nimport { sql as drizzleSql, type SQL } from 'drizzle-orm';\nimport type { PostgresExecutor } from '../executor.js';\nimport { splitPositionalSql } from '../positional-sql.js';\n\n/** What a Drizzle database and a Drizzle transaction have in common. */\nexport interface DrizzleQueryable {\n  execute(query: SQL): PromiseLike<{ readonly rows: Record<string, unknown>[] }>;\n}\n\n/** The part of a Drizzle `node-postgres` database the executor uses. */\nexport interface DrizzleLike extends DrizzleQueryable {\n  transaction<T>(work: (transaction: DrizzleQueryable) => Promise<T>): Promise<T>;\n}\n\n/**\n * Executor for Drizzle with the `node-postgres` driver. The transaction handle\n * is a Drizzle transaction: pass `tx` from `db.transaction(async (tx) => ...)`.\n */\nexport function createDrizzleExecutor(database: DrizzleLike): PostgresExecutor<DrizzleQueryable> {\n  return adapterExecutor<DrizzleQueryable>({\n    root: database,\n    transaction: (work) => database.transaction(work),\n    async run(queryable, { sql, parameters }) {\n      const chunks = splitPositionalSql(sql).map((part) =>\n        typeof part === 'string'\n          ? drizzleSql.raw(part)\n          : drizzleSql.param(parameters[part.parameterIndex]),\n      );\n      const result = await queryable.execute(drizzleSql.join(chunks));\n      return result.rows;\n    },\n  });\n}\n"]}

package/dist/{executor-VZGmsMX4.d.cts → executor-CfJgktC6.d.cts}

@@ -27,7 +27,24 @@ interface PostgresQueryOptions {
  * - `options` are hints ({@link PostgresQueryOptions}); ignoring them is correct, only slower.
  */
 interface PostgresExecutor<TTransaction> {
+    /**
+     * True when the process keeps running if the server ends the session of an open transaction
+     * (an `error` listener is on the connection while the transaction runs). The store then holds
+     * `bus.transaction` to its budget with `idle_in_transaction_session_timeout` and, on PostgreSQL
+     * 17+, `transaction_timeout` as well as `statement_timeout`. Without it only `statement_timeout`
+     * is set: a `pg` client checked out by another library without an `error` listener would crash
+     * the process with an unhandled `error` event when the server ends its session. `PgExecutor`
+     * sets it.
+     */
+    readonly sessionTimeouts?: boolean;
     transaction<T>(work: (transaction: TTransaction) => Promise<T>): Promise<T>;
+    /**
+     * Optional. Opens a transaction like {@link PostgresExecutor.transaction} that the server holds to
+     * `timeoutMs` (`statement_timeout`, plus the session timeouts when {@link sessionTimeouts} is set),
+     * set in the round trip of its `BEGIN`. Without it the store sets the budget with a statement of
+     * its own, one round trip more per `bus.transaction`. `PgExecutor` implements it.
+     */
+    transactionWithBudget?<T>(work: (transaction: TTransaction) => Promise<T>, timeoutMs: number): Promise<T>;
     query(sql: string, parameters: readonly PostgresParameter[], transaction?: TTransaction, options?: PostgresQueryOptions): Promise<readonly PostgresRow[]>;
 }
 

package/dist/{executor-VZGmsMX4.d.ts → executor-CfJgktC6.d.ts}

@@ -27,7 +27,24 @@ interface PostgresQueryOptions {
  * - `options` are hints ({@link PostgresQueryOptions}); ignoring them is correct, only slower.
  */
 interface PostgresExecutor<TTransaction> {
+    /**
+     * True when the process keeps running if the server ends the session of an open transaction
+     * (an `error` listener is on the connection while the transaction runs). The store then holds
+     * `bus.transaction` to its budget with `idle_in_transaction_session_timeout` and, on PostgreSQL
+     * 17+, `transaction_timeout` as well as `statement_timeout`. Without it only `statement_timeout`
+     * is set: a `pg` client checked out by another library without an `error` listener would crash
+     * the process with an unhandled `error` event when the server ends its session. `PgExecutor`
+     * sets it.
+     */
+    readonly sessionTimeouts?: boolean;
     transaction<T>(work: (transaction: TTransaction) => Promise<T>): Promise<T>;
+    /**
+     * Optional. Opens a transaction like {@link PostgresExecutor.transaction} that the server holds to
+     * `timeoutMs` (`statement_timeout`, plus the session timeouts when {@link sessionTimeouts} is set),
+     * set in the round trip of its `BEGIN`. Without it the store sets the budget with a statement of
+     * its own, one round trip more per `bus.transaction`. `PgExecutor` implements it.
+     */
+    transactionWithBudget?<T>(work: (transaction: TTransaction) => Promise<T>, timeoutMs: number): Promise<T>;
     query(sql: string, parameters: readonly PostgresParameter[], transaction?: TTransaction, options?: PostgresQueryOptions): Promise<readonly PostgresRow[]>;
 }