@relaybus/postgres 0.3.0 → 0.4.0

package/README.md

@@ -102,15 +102,29 @@ Where the budget lives depends on who owns the pool:
 - **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.
+**Prisma** is integration-tested with a generated Prisma Client 7.10 (and 6.19 in CI) on the `@prisma/adapter-pg`
+driver adapter: the full event store contract, publishing in `prisma.$transaction`, rollback and concurrent
+transactions. The adapter is typed structurally, so the package has no Prisma dependency. Prisma interactive
+transactions default to a 5 s timeout, so pass `createPrismaExecutor(prisma, { timeout, maxWait })` if handlers run
+longer.
+
+**Give an ORM store the `pg` pool too.** ORMs send raw statements unprepared and offer no connection to `LISTEN` on.
+Pass the `pg` pool your ORM's driver uses as `pool` next to `executor`: the statements the store sends outside your
+transactions (the dispatcher's claims, completions and renewals) then run on it as prepared statements, and the
+store listens for wake-ups, so an event published in your ORM transaction is dispatched right after that
+transaction commits. Your transactions still go through the ORM, and the store never closes the pool.
+
+```ts
+const pool = new Pool({ connectionString });
+const prisma = new PrismaClient({ adapter: new PrismaPg(pool) });
+const store = new PostgresEventStore({ executor: createPrismaExecutor(prisma), pool });
+```
 
 ## Options
 
 | Option                                   | Default               | Meaning                                                                                                            |
 | ---------------------------------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------ |
-| `pool` / `connectionString` / `executor` | required, exactly one | How to reach the database.                                                                                         |
+| `pool` / `connectionString` / `executor` | required, exactly one | How to reach the database. With `executor`, `pool` may be given too (see above).                                   |
 | `poolConfig`                             | none                  | Extra `pg` pool settings when `connectionString` is used.                                                          |
 | `schema`                                 | `'public'`            | Schema of the tables. Created by `setup()` when it is not `public`.                                                |
 | `tablePrefix`                            | `'relaybus_'`         | Tables are `<prefix>events`, `<prefix>deliveries`, `<prefix>key_sequences`, `<prefix>lanes`.                       |
@@ -274,11 +288,16 @@ tool, run it as one transaction with the workers stopped. Running 0.1.0 and the
   that channel (`<schema>.<prefix>deliveries`, hashed when longer than 63 characters) on one connection of its own,
   opened with the pool's settings outside the pool, so an event published by any process runs within milliseconds
   instead of at the next poll. A lost listening connection is replaced after a second; polling remains the safety
-  net, so a missed notification only costs latency. A store built on an `executor` cannot listen and relies on
-  polling (and on the wake-up of its own process after a publish). `wakeUp: 'poll'` sends and listens for nothing.
+  net, so a missed notification only costs latency. The notification of a publish in your own transaction is sent
+  by PostgreSQL at its commit, however late that is, so the handler starts within milliseconds of the commit
+  (`wake-after-commit.integration.test.ts`). A store built on an `executor` listens only when it is given `pool`
+  as well; without it, it relies on polling and on the wake-ups of its own process after a publish (see
+  `bus.wake()`). `wakeUp: 'poll'` sends and listens for nothing.
 - **Prepared statements.** With `preparedStatements: true` (the default) the publish, claim, completion and renewal
   statements are named prepared statements: each connection parses and plans them once. Only `PgExecutor` (the
-  default `pool` / `connectionString` path) prepares; the library adapters send every statement unprepared. See
+  default `pool` / `connectionString` path, and the `pool` given next to an `executor`) prepares; the library
+  adapters send the statements of your transactions unprepared (a dispatch batch on an ORM store parses 2 statements
+  without `pool`, 0 with it: `perf-design-orm-executors.integration.test.ts`). See
   `docs/performance/publish-path.md` for what that saves.
 - **Pooling.** Claim, complete, extend and purge need a free connection besides your transactions; size the pool for
   `dispatcher.concurrency` plus publishers; the listening connection comes on top of the pool's `max`. Listening and
@@ -310,12 +329,12 @@ tool, run it as one transaction with the workers stopped. Running 0.1.0 and the
 ## Testing
 
 Integration tests use Testcontainers against `postgres:17-alpine` and `postgres:13-alpine` (override with
-`RELAYBUS_POSTGRES_IMAGES`). Every adapter except Prisma runs the full `@relaybus/testing` event store contract plus
-transaction tests against the real database.
+`RELAYBUS_POSTGRES_IMAGES`). Every adapter (Kysely, Knex, TypeORM, Drizzle, Prisma with and without `pool`) runs the
+full `@relaybus/testing` event store contract plus transaction tests against the real database.
 
 ## When to use @relaybus/postgres, and when not to
 
-Use it when your data lives in PostgreSQL 13 or newer and events must commit or roll back with it. It is not for MySQL or MongoDB (see `@relaybus/mongodb` for MongoDB), and the Prisma adapter is typed and unit-tested but not yet integration-tested.
+Use it when your data lives in PostgreSQL 13 or newer and events must commit or roll back with it. It is not for MySQL or MongoDB (see `@relaybus/mongodb` for MongoDB).
 
 Documentation: <https://berkcansavur.github.io/relaybus/packages/postgres>
 

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,17 +25,17 @@ function splitPositionalSql(sql) {
 
 // src/drizzle/drizzle-executor.ts
 function createDrizzleExecutor(database) {
-  return {
+  return adapterExecutor({
+    root: database,
     transaction: (work) => database.transaction(work),
-    // eslint-disable-next-line relaybus/max-two-params -- PostgresExecutor port signature
-    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;AAAA,IAEhD,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    // eslint-disable-next-line relaybus/max-two-params -- PostgresExecutor port signature\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-CfJgktC6.cjs';
+import { PostgresExecutor } from './index.cjs';
 
 /** What a Drizzle database and a Drizzle transaction have in common. */
 interface DrizzleQueryable {
@@ -17,4 +17,5 @@ interface DrizzleLike extends DrizzleQueryable {
  */
 declare function createDrizzleExecutor(database: DrizzleLike): PostgresExecutor<DrizzleQueryable>;
 
-export { type DrizzleLike, type DrizzleQueryable, createDrizzleExecutor };
+export { createDrizzleExecutor };
+export type { DrizzleLike, DrizzleQueryable };

package/dist/drizzle.d.ts

@@ -1,5 +1,5 @@
 import { SQL } from 'drizzle-orm';
-import { P as PostgresExecutor } from './executor-CfJgktC6.js';
+import { PostgresExecutor } from './index.js';
 
 /** What a Drizzle database and a Drizzle transaction have in common. */
 interface DrizzleQueryable {
@@ -17,4 +17,5 @@ interface DrizzleLike extends DrizzleQueryable {
  */
 declare function createDrizzleExecutor(database: DrizzleLike): PostgresExecutor<DrizzleQueryable>;
 
-export { type DrizzleLike, type DrizzleQueryable, createDrizzleExecutor };
+export { createDrizzleExecutor };
+export type { DrizzleLike, DrizzleQueryable };

package/dist/drizzle.js

@@ -1,18 +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),
-    // eslint-disable-next-line relaybus/max-two-params -- PostgresExecutor port signature
-    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;AAAA,IAEhD,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    // eslint-disable-next-line relaybus/max-two-params -- PostgresExecutor port signature\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"]}