@aventara/prisma7-adapter 1.0.0-rc.12 → 1.0.0-rc.14

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # @aventara/prisma7-adapter
 
+## 1.0.0-rc.14
+
+### Patch Changes
+
+- 28688e4: On SQLite (`@prisma/adapter-better-sqlite3`), a plain operation or `ctx.$sql` that gives up waiting for the connection another request's transaction holds still answers `A3002`, and its diagnostic now says so: how many milliseconds it waited, the `maxWait` that ran out (the adapter's `transactionOptions.maxWait`, or else the PrismaClient's, 2000 ms unless set on the client), and that it never ran. A transaction that fails to open for another reason, such as an unsupported isolation level, keeps its usual diagnostic. Before, the diagnostic said the call's transaction "was no longer open", which named the wrong cause. Raise the adapter's `transactionOptions.maxWait`, or keep the transaction that holds the connection shorter.
+- Updated dependencies [1c5eaa3]
+  - @aventara/core@1.0.0-rc.14
+
+## 1.0.0-rc.13
+
+### Patch Changes
+
+- 66b31b5: With SQLite through `@prisma/adapter-better-sqlite3`, a plain operation no longer runs inside another request's open
+  transaction. That driver has one connection, and an interactive transaction holds it while it waits between
+  statements; Prisma ran a plain statement on that same connection without waiting, so an unforced write made meanwhile
+  rolled back with the other request's transaction, and an unforced read saw its uncommitted rows. With that driver, an
+  operation that is not part of a transaction, and a `ctx.$sql` that is not, now each run in a transaction of their own
+  that holds only that call, so they wait until the open transaction ends. `transactionOptions` apply to that wait: past
+  `maxWait` the operation answers `A3002`, and `timeout` limits a single plain operation too. A plain call made from
+  inside a transaction's own async context (a stage calling the root Framework instead of its `ctx`) joins that
+  transaction instead of waiting on it, and warns (`AVENTARA_PRISMA_SQLITE_TRANSACTION_JOINED`) once per Resource and operation and once for `ctx.$sql`,
+  because a helper shared across requests can carry that context into another request's call. PostgreSQL and D1 run as
+  before. A mismatched `driver` declaration is now refused at construction: `createPrismaAdapter` throws when the Prisma
+  client was constructed with another driver adapter than the declared `driver`, and names the supported set
+  (`@prisma/adapter-better-sqlite3`, `@prisma/adapter-pg`, `@prisma/adapter-d1`); a client built with any other driver
+  adapter is not supported.
+- Updated dependencies [6c3e25c]
+- Updated dependencies [2aaa27d]
+- Updated dependencies [f3b291f]
+- Updated dependencies [2aaa27d]
+- Updated dependencies [e4e8abd]
+- Updated dependencies [e662048]
+- Updated dependencies [f3b291f]
+- Updated dependencies [f3b291f]
+- Updated dependencies [6c3e25c]
+- Updated dependencies [6c3e25c]
+- Updated dependencies [a708188]
+- Updated dependencies [a9260d2]
+  - @aventara/core@1.0.0-rc.13
+
 ## 1.0.0-rc.12
 
 ### Patch Changes

package/README.md

@@ -50,7 +50,10 @@ const framework = await createFramework({ api: "/api", adapter });
 
 The caller declares `provider` and `driver`. The adapter does not inspect client internals to guess
 them: the driver decides whether transactions are advertised at all, and a wrong guess would be worse
-than a declaration that is checked.
+than a declaration that is checked. It does check the declaration: when the client names the driver
+adapter it was constructed with (Prisma 7.10 keeps it where its own D1 check reads it), a `driver` that
+differs refuses to start (`AvPrismaDiscoveryArtifactError`, naming both). A client that does not say,
+such as a test double, is not compared.
 
 `createPrismaAdapter` is `async`. Construction verifies the discovery artifact, and the digest it
 checks is a `crypto.subtle` promise, so every check runs once, here, before an adapter exists.
@@ -90,6 +93,62 @@ The supported isolation levels come from the declared provider. PostgreSQL admit
 `ReadCommitted`, `RepeatableRead` and `Serializable`; SQLite admits `Serializable` only. Asking for a
 level the provider does not support fails the transaction; see [`P2028`](#p2028-covers-seven-situations-and-three-of-them-are-separable).
 
+### SQLite: one connection
+
+`@prisma/adapter-better-sqlite3` holds one connection, and an interactive transaction holds it from `BEGIN`
+to `COMMIT`, including while it waits between statements. Prisma runs a plain statement on that same
+connection without waiting, so a plain call made meanwhile would run inside the open transaction: it would
+see its uncommitted rows and roll back with it. With that driver, an operation that is not part of a
+transaction, and a `ctx.$sql` that is not, each run in a `$transaction` of their own that holds only that
+call. They wait on the driver's own lock, so operations and transactions queue for the connection and run
+one at a time. `transactionOptions` apply to the wait: past `maxWait` the operation answers `A3002`, its
+diagnostic says how long it waited for the connection another request's transaction held, and
+`timeout` limits a single plain operation too. `@prisma/adapter-pg` checks a connection of its own out of
+the pool for each transaction, and D1 runs none, so both stay as they were. Calls made on the Prisma client
+directly, outside Aventara, are not covered.
+
+#### A call from inside a transaction joins it, and warns
+
+A plain call made from inside an open transaction's own async context, such as a stage that calls the root
+Framework instead of its `ctx`, would otherwise queue behind the very transaction it runs in and fail after
+`maxWait`. So it joins that transaction instead: it runs on the transaction's connection and commits or
+rolls back with it, as it did before the queue existed. The adapter knows which transaction a call belongs
+to only from Node's `AsyncLocalStorage`. The first time a given Resource and operation joins, the process
+warns once (and once for `ctx.$sql`):
+
+```text
+(node:4711) [AVENTARA_PRISMA_SQLITE_TRANSACTION_JOINED] AventaraWarning: Author create.many ran inside an
+open SQLite transaction (better-sqlite3) instead of waiting for it: it was called from that transaction's
+async context, so it joined the transaction and commits or rolls back with it. …
+```
+
+A join you meant (the stage above) is fine, and the warning is expected for it. A join you did not mean
+comes from a helper shared across requests that runs another request's work in the async context it was
+first called from. A naive batcher is the usual one:
+
+```ts
+let pending: Array<{ email: string }> = [];
+let flushing: ReturnType<typeof setTimeout> | undefined;
+
+export function addAuthor(email: string) {
+  pending.push({ email });
+  // Scheduled inside request A's transaction (say, from an after hook), the timer
+  // keeps A's async context. Request B's author, added before the flush, is then
+  // written inside A's transaction and rolls back if A does.
+  flushing ??= setTimeout(() => {
+    const data = pending;
+    pending = [];
+    flushing = undefined;
+    void framework.application.Author.create.many({ data });
+  }, 50);
+}
+```
+
+Give such a helper its own context: bind its callback with `AsyncResource.bind` from `node:async_hooks`
+when it is created (`const flush = AsyncResource.bind(() => { … })`, created at module load, outside any
+transaction), or schedule its timers from outside a transaction. The join is never refused, because code
+that joins on purpose has to keep working.
+
 ---
 
 ## The generate step, and the artifact it emits

package/dist/adapter-warning.emitter.d.ts

@@ -0,0 +1,2 @@
+/** Emits an `AventaraWarning` with `code`, or logs it where there is no `process.emitWarning`. */
+export declare function emitAdapterWarning(message: string, code: string): void;

package/dist/adapter-warning.emitter.js

@@ -0,0 +1,8 @@
+export function emitAdapterWarning(message, code) {
+    const emitWarning = globalThis.process?.emitWarning;
+    if (typeof emitWarning === "function") {
+        emitWarning(message, { type: "AventaraWarning", code });
+        return;
+    }
+    globalThis.console?.warn(`AventaraWarning: ${message}`);
+}

package/dist/discovery/client-shape.verifier.d.ts

@@ -6,3 +6,11 @@ import type { PrismaClientShape } from "./discovery-artifact.interface.js";
  * @throws AvPrismaDiscoveryArtifactError
  */
 export declare function assertClientMatchesArtifact(recorded: PrismaClientShape, client: unknown): void;
+/**
+ * Throws when the Prisma client in hand was constructed with another driver
+ * adapter than the declared `driver` (one outside the supported set included);
+ * skips when the client does not say.
+ *
+ * @throws AvPrismaDiscoveryArtifactError
+ */
+export declare function assertClientUsesDeclaredDriver(driver: string, client: unknown): void;

package/dist/discovery/client-shape.verifier.js

@@ -1,4 +1,5 @@
 import { delegateKeyOf } from "../execution/operation.executor.js";
+import { PRISMA_DRIVERS } from "../provider/provider-profile.js";
 import { AvPrismaDiscoveryArtifactError } from "./artifact.loader.js";
 const SHOWN = 3;
 function readMember(value, key) {
@@ -91,3 +92,16 @@ export function assertClientMatchesArtifact(recorded, client) {
     const more = drift.length > SHOWN ? `; and ${drift.length - SHOWN} more` : "";
     throw new AvPrismaDiscoveryArtifactError(`The Prisma client has changed since the discovery artifact was generated (${shown}${more}):`, "run `npm run aventara:prepare` (the adapter's `aventara-prisma7-generate`) to regenerate it, then restart.");
 }
+const SUPPORTED_DRIVERS = `${PRISMA_DRIVERS.slice(0, -1)
+    .map((name) => `\`${name}\``)
+    .join(", ")} and \`${PRISMA_DRIVERS[PRISMA_DRIVERS.length - 1]}\``;
+export function assertClientUsesDeclaredDriver(driver, client) {
+    const constructedWith = readMember(readMember(readMember(client, "_engineConfig"), "adapter"), "adapterName");
+    if (typeof constructedWith !== "string" || constructedWith === driver) {
+        return;
+    }
+    const supported = PRISMA_DRIVERS.includes(constructedWith);
+    throw new AvPrismaDiscoveryArtifactError(`The Prisma client is constructed with the driver adapter \`${constructedWith}\`, but createPrismaAdapter was given \`driver: "${driver}"\`.`, `@aventara/prisma7-adapter supports the driver adapters ${SUPPORTED_DRIVERS}; ${supported
+        ? `declare \`driver: "${constructedWith}"\`, then restart.`
+        : `a client constructed with any other driver adapter is not supported.`}`);
+}

package/dist/errors/error.normalizer.d.ts

@@ -66,6 +66,21 @@ export declare function classifyPrismaError(error: unknown, operation: Pick<AvOp
 export declare function classifyPrismaStatementError(error: unknown): PrismaErrorClassification;
 /** The deliberate failure an `outcome` classification stands for. */
 export declare function prismaOutcomeFailure(code: AvOperationErrorCode): AvError;
+/**
+ * Whether a failure to open a transaction has the structure of the `maxWait`
+ * acquisition timeout: `P2028` with an empty `meta`.
+ */
+export declare function isPrismaAcquisitionTimeout(error: unknown): boolean;
+/**
+ * `A3002` for a plain call on a one-connection driver that gave up waiting for
+ * the connection another request's transaction held: its own transaction never
+ * opened, so `OUTCOME_MESSAGES`' "no longer open" text would name the wrong
+ * cause. Diagnostics only, like every `A3xxx` text here.
+ */
+export declare function prismaConnectionWaitFailure(facts: {
+    readonly waitedMs: number;
+    readonly maxWait: number | undefined;
+}): AvError;
 /** The `A2004` a value the database refused answers: one issue at the arguments (or the value in them) saying what was refused. */
 export declare function prismaValueFailure(refusal: PrismaValueRefusal, path?: PrismaArgumentPath): AvError;
 /** The `A2004` a nested write that writes its relation back answers: `V1012` at `path`. */

package/dist/errors/error.normalizer.js

@@ -127,6 +127,18 @@ export function prismaOutcomeFailure(code) {
         message: OUTCOME_MESSAGES[code] ?? "The operation could not be completed.",
     });
 }
+export function isPrismaAcquisitionTimeout(error) {
+    const facts = readPrismaError(error);
+    return facts.code === "P2028" && facts.metaKeys.length === 0;
+}
+export function prismaConnectionWaitFailure(facts) {
+    const limit = facts.maxWait === undefined
+        ? "the PrismaClient's maxWait (2000 ms unless set on the client)"
+        : `the adapter's maxWait (${facts.maxWait} ms)`;
+    return new AvError("A3002", {
+        message: `This call waited ${Math.round(facts.waitedMs)} ms for the SQLite connection, which another request's transaction held, and gave up when ${limit} ran out: it never ran and wrote nothing. Raise the adapter's transactionOptions.maxWait, or keep the transaction that holds the connection shorter.`,
+    });
+}
 export function prismaValueFailure(refusal, path = []) {
     const { code, message } = DATABASE_REFUSALS[refusal];
     return new AvError("A2004", {

package/dist/execution/shared-connection.router.d.ts

@@ -0,0 +1,25 @@
+import type { AvAdapterOperation } from "@aventara/core/internal";
+import type { AvPrismaDelegateHost, AvPrismaTransactionOptions } from "../prisma-client.interface.js";
+/** What a plain call is, for the warning a join emits: an operation, or a `ctx.$sql` statement. */
+export type PrismaPlainCall = AvAdapterOperation | "ctx.$sql";
+/** How plain work and transactions share a driver's one connection. */
+export type PrismaSharedConnectionRouter = {
+    /**
+     * Runs plain work on the transaction this async flow is inside (and warns,
+     * once per `call`), or else in a one-statement transaction of its own; a
+     * failure to open or commit that transaction is classified through the
+     * closed table.
+     */
+    plain<T>(call: PrismaPlainCall, work: (client: AvPrismaDelegateHost) => Promise<T>): Promise<T>;
+    /**
+     * Runs a transaction's work so that plain work issued from inside it joins
+     * it. The work's own promise is returned as is: its rejection reaches Prisma
+     * by reference (core recognises its abort sentinel by identity).
+     */
+    within<T>(transactional: AvPrismaDelegateHost, work: () => Promise<T>): Promise<T>;
+};
+/** The router for a shared-connection driver's client. */
+export declare function createSharedConnectionRouter(dependencies: {
+    readonly client: AvPrismaDelegateHost;
+    readonly transactionOptions?: AvPrismaTransactionOptions;
+}): PrismaSharedConnectionRouter;

package/dist/execution/shared-connection.router.js

@@ -0,0 +1,80 @@
+import { emitAdapterWarning } from "../adapter-warning.emitter.js";
+import { classifyPrismaStatementError, isPrismaAcquisitionTimeout, prismaConnectionWaitFailure, prismaOutcomeFailure, } from "../errors/error.normalizer.js";
+const TRANSACTION_JOINED_WARNING = "AVENTARA_PRISMA_SQLITE_TRANSACTION_JOINED";
+const warnedJoins = new Set();
+function warnJoined(call) {
+    const subject = call === "ctx.$sql"
+        ? call
+        : `${call.resource} ${call.family}.${call.variant}`;
+    if (warnedJoins.has(subject)) {
+        return;
+    }
+    warnedJoins.add(subject);
+    emitAdapterWarning(`${subject} ran inside an open SQLite transaction (better-sqlite3) instead of waiting for it: it was called from that transaction's async context, so it joined the transaction and commits or rolls back with it. That is intended when the transaction's own work makes the call, such as a stage calling the root Framework instead of its ctx. If the call came through a helper shared across requests (a batcher, a queue, a timer first scheduled inside a transaction), it is another request's call and has joined a transaction that is not its own: bind the helper's callbacks with AsyncResource.bind, or schedule them outside the transaction. ${call === "ctx.$sql" ? "Warned once for ctx.$sql." : "Warned once per Resource and operation."}`, TRANSACTION_JOINED_WARNING);
+}
+function createFlowStorage() {
+    const process = globalThis.process;
+    const hooks = process?.getBuiltinModule?.("node:async_hooks");
+    return typeof hooks?.AsyncLocalStorage === "function"
+        ? new hooks.AsyncLocalStorage()
+        : undefined;
+}
+export function createSharedConnectionRouter(dependencies) {
+    const flows = createFlowStorage();
+    const within = (transactional, work) => {
+        if (flows === undefined) {
+            return work();
+        }
+        const entry = { client: transactional, open: true };
+        const settled = flows.run(entry, work);
+        const close = () => {
+            entry.open = false;
+        };
+        settled.then(close, close);
+        return settled;
+    };
+    const plain = async (call, work) => {
+        const joined = flows?.getStore();
+        if (joined?.open === true) {
+            warnJoined(call);
+            return work(joined.client);
+        }
+        let thrownByWork = false;
+        let started = false;
+        const run = async (transactional) => {
+            started = true;
+            try {
+                return await within(transactional, () => work(transactional));
+            }
+            catch (error) {
+                thrownByWork = true;
+                throw error;
+            }
+        };
+        const options = dependencies.transactionOptions;
+        const waitedFrom = performance.now();
+        try {
+            return await (options === undefined
+                ? dependencies.client.$transaction(run)
+                : dependencies.client.$transaction(run, options));
+        }
+        catch (error) {
+            if (thrownByWork) {
+                throw error;
+            }
+            const classification = classifyPrismaStatementError(error);
+            if (classification.kind === "outcome") {
+                const waitedMs = performance.now() - waitedFrom;
+                const maxWait = options?.maxWait;
+                const waitedOut = !started &&
+                    isPrismaAcquisitionTimeout(error) &&
+                    (maxWait === undefined || waitedMs + 1 >= maxWait);
+                throw waitedOut
+                    ? prismaConnectionWaitFailure({ waitedMs, maxWait })
+                    : prismaOutcomeFailure(classification.code);
+            }
+            throw error;
+        }
+    };
+    return { plain, within };
+}

package/dist/execution/transaction.executor.d.ts

@@ -4,6 +4,7 @@ import type { PrismaResourceTranslation } from "../discovery/discovery-artifact.
 import type { PrismaBackReferenceTable } from "../errors/back-reference.locator.js";
 import type { AvPrismaDelegateHost, AvPrismaTransactionOptions } from "../prisma-client.interface.js";
 import type { PrismaBigintBinding } from "../provider/provider-profile.js";
+import type { PrismaSharedConnectionRouter } from "./shared-connection.router.js";
 type PrismaTransactionExecutorDependencies = {
     readonly client: AvPrismaDelegateHost;
     readonly model: AvAdapterModel;
@@ -12,6 +13,7 @@ type PrismaTransactionExecutorDependencies = {
     readonly backReferences: PrismaBackReferenceTable;
     readonly bigintBinding: PrismaBigintBinding;
     readonly transactionOptions?: AvPrismaTransactionOptions;
+    readonly sharedConnection?: PrismaSharedConnectionRouter;
 };
 type PrismaTransactionRunner<M extends AvAdapterModel> = <T>(work: (executor: AvAdapterTransactionExecutor<M>) => Promise<T>) => Promise<T>;
 export declare function createPrismaTransactionExecutor<M extends AvAdapterModel>(dependencies: PrismaTransactionExecutorDependencies): PrismaTransactionRunner<M>;

package/dist/execution/transaction.executor.js

@@ -13,7 +13,13 @@ export function createPrismaTransactionExecutor(dependencies) {
         }),
         executeSql: createPrismaSqlStatementExecutor(transactional),
     });
-    return (work) => options === undefined
-        ? dependencies.client.$transaction(async (transactional) => work(scopedExecutorFor(transactional)))
-        : dependencies.client.$transaction(async (transactional) => work(scopedExecutorFor(transactional)), options);
+    const router = dependencies.sharedConnection;
+    return (work) => {
+        const run = async (transactional) => router === undefined
+            ? work(scopedExecutorFor(transactional))
+            : router.within(transactional, () => work(scopedExecutorFor(transactional)));
+        return options === undefined
+            ? dependencies.client.$transaction(run)
+            : dependencies.client.$transaction(run, options);
+    };
 }

package/dist/prisma.adapter.d.ts

@@ -41,7 +41,8 @@ type PrismaAdapterConstruction<TClient extends AvPrismaDelegateHost, M extends A
  * ```
  *
  * @throws `AvPrismaDiscoveryArtifactError` when the artifact is stale, corrupt or
- * was generated for another Prisma major; its message says how to regenerate it.
+ * was generated for another Prisma major (its message says how to regenerate
+ * it), or when the client was constructed with another driver than `driver`.
  */
 export declare function createPrismaAdapter<TClient extends AvPrismaDelegateHost, M extends AvPrismaAdapterModel = AvPrismaAdapterModel>(options: PrismaAdapterConstruction<TClient, M>): Promise<AvAdapter<M>>;
 export {};

package/dist/prisma.adapter.js

@@ -1,12 +1,14 @@
+import { emitAdapterWarning } from "./adapter-warning.emitter.js";
 import { loadDiscoveryArtifact } from "./discovery/artifact.loader.js";
-import { assertClientMatchesArtifact } from "./discovery/client-shape.verifier.js";
+import { assertClientMatchesArtifact, assertClientUsesDeclaredDriver, } from "./discovery/client-shape.verifier.js";
 import { locateInstalledPrismaClientVersion } from "./discovery/installed-client.locator.js";
 import { derivePrismaBackReferences } from "./errors/back-reference.locator.js";
 import { createPrismaOperationExecutor } from "./execution/operation.executor.js";
+import { createSharedConnectionRouter } from "./execution/shared-connection.router.js";
 import { createPrismaSqlStatementExecutor } from "./execution/sql-statement.executor.js";
 import { createPrismaTransactionExecutor } from "./execution/transaction.executor.js";
 import { describePrismaAdapter } from "./prisma-adapter.description.js";
-import { resolveBigintBinding, } from "./provider/provider-profile.js";
+import { resolveBigintBinding, resolveTransactionConnection, } from "./provider/provider-profile.js";
 const PRISMA_VERSION_UNCHECKED_WARNING = "AVENTARA_PRISMA_VERSION_UNCHECKED";
 function installedClientVersion(discovery, override) {
     if (override !== undefined) {
@@ -17,16 +19,7 @@ function installedClientVersion(discovery, override) {
         return located.version;
     }
     const message = `the installed @prisma/client's version could not be read (${located.reason}), so the discovery artifact's Prisma major (${String(discovery.prismaVersion).split(".")[0]}) was not compared with the installed @prisma/client's. Deploy @prisma/client where the application resolves it, or pass installedPrismaVersion to createPrismaAdapter.`;
-    const emitWarning = globalThis.process?.emitWarning;
-    if (typeof emitWarning === "function") {
-        emitWarning(message, {
-            type: "AventaraWarning",
-            code: PRISMA_VERSION_UNCHECKED_WARNING,
-        });
-    }
-    else {
-        globalThis.console?.warn(`AventaraWarning: ${message}`);
-    }
+    emitAdapterWarning(message, PRISMA_VERSION_UNCHECKED_WARNING);
     return undefined;
 }
 export async function createPrismaAdapter(options) {
@@ -36,6 +29,7 @@ export async function createPrismaAdapter(options) {
         installedPrismaVersion: installedClientVersion(options.discovery, options.installedPrismaVersion),
     });
     assertClientMatchesArtifact(options.discovery.client, options.client);
+    assertClientUsesDeclaredDriver(options.driver, options.client);
     const model = description.model;
     const referentialActions = description.referentialActions;
     const backReferences = derivePrismaBackReferences(options.discovery.model);
@@ -43,18 +37,38 @@ export async function createPrismaAdapter(options) {
     const computedFields = description.computedFields === undefined
         ? {}
         : { computedFields: description.computedFields };
-    const { execute } = createPrismaOperationExecutor({
-        client: options.client,
+    const translation = options.discovery.translation;
+    const transactionOptions = options.transactionOptions === undefined
+        ? {}
+        : { transactionOptions: options.transactionOptions };
+    const sharedConnection = resolveTransactionConnection(options.driver) === "shared"
+        ? createSharedConnectionRouter({
+            client: options.client,
+            ...transactionOptions,
+        })
+        : undefined;
+    const executorDependencies = {
         model: options.discovery.model,
-        translation: options.discovery.translation,
+        translation,
         backReferences,
         bigintBinding,
-        scope: "root",
-        ...(options.transactionOptions === undefined
-            ? {}
-            : { transactionOptions: options.transactionOptions }),
-    });
-    const executeSql = createPrismaSqlStatementExecutor(options.client);
+    };
+    const execute = sharedConnection === undefined
+        ? createPrismaOperationExecutor({
+            ...executorDependencies,
+            client: options.client,
+            scope: "root",
+            ...transactionOptions,
+        }).execute
+        : (operation) => sharedConnection.plain(operation, (transactional) => createPrismaOperationExecutor({
+            ...executorDependencies,
+            client: transactional,
+            scope: "transaction",
+        }).execute(operation));
+    const rootSql = createPrismaSqlStatementExecutor(options.client);
+    const executeSql = sharedConnection === undefined
+        ? rootSql
+        : (statement) => sharedConnection.plain("ctx.$sql", (transactional) => createPrismaSqlStatementExecutor(transactional)(statement));
     if (description.transactions === "none") {
         return {
             model,
@@ -68,12 +82,11 @@ export async function createPrismaAdapter(options) {
     const transaction = createPrismaTransactionExecutor({
         client: options.client,
         model: options.discovery.model,
-        translation: options.discovery.translation,
+        translation,
         backReferences,
         bigintBinding,
-        ...(options.transactionOptions === undefined
-            ? {}
-            : { transactionOptions: options.transactionOptions }),
+        ...transactionOptions,
+        ...(sharedConnection === undefined ? {} : { sharedConnection }),
     });
     return {
         model,

package/dist/provider/provider-profile.d.ts

@@ -35,6 +35,10 @@ export type AvPrismaProviderProfile = {
 };
 /** How a driver binds a `bigint` parameter: all 64 bits, or as a JavaScript safe integer. */
 export type PrismaBigintBinding = "int64" | "safe-integer";
+/** Whether an open interactive transaction holds the connection plain statements use. */
+export type PrismaTransactionConnection = "shared" | "separate";
+/** Whether the declared driver's open transaction holds its plain statements' connection. */
+export declare function resolveTransactionConnection(driver: AvPrismaDriver): PrismaTransactionConnection;
 /** How the declared driver binds a `bigint` parameter. */
 export declare function resolveBigintBinding(driver: AvPrismaDriver): PrismaBigintBinding;
 /**

package/dist/provider/provider-profile.js

@@ -14,6 +14,14 @@ const DRIVER_BIGINT_BINDING = {
     "@prisma/adapter-pg": "int64",
     "@prisma/adapter-d1": "safe-integer",
 };
+const DRIVER_TRANSACTION_CONNECTION = {
+    "@prisma/adapter-better-sqlite3": "shared",
+    "@prisma/adapter-pg": "separate",
+    "@prisma/adapter-d1": "separate",
+};
+export function resolveTransactionConnection(driver) {
+    return DRIVER_TRANSACTION_CONNECTION[driver];
+}
 export function resolveBigintBinding(driver) {
     return DRIVER_BIGINT_BINDING[driver];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aventara/prisma7-adapter",
-  "version": "1.0.0-rc.12",
+  "version": "1.0.0-rc.14",
   "license": "SEE LICENSE IN LICENSE",
   "description": "The Prisma 7 adapter for Aventara.",
   "type": "module",
@@ -30,7 +30,7 @@
     "CHANGELOG.md"
   ],
   "dependencies": {
-    "@aventara/core": "1.0.0-rc.12"
+    "@aventara/core": "1.0.0-rc.14"
   },
   "peerDependencies": {
     "@prisma/adapter-better-sqlite3": "^7.10.1",
@@ -95,9 +95,10 @@
     "build": "node ../../scripts/build/build-output.cleaner.ts dist && node node_modules/typescript/bin/tsc -p tsconfig.json --removeComments --declaration false && node node_modules/typescript/bin/tsc -p tsconfig.json --emitDeclarationOnly && node ../../scripts/build/declaration-comments.sanitizer.ts dist",
     "typecheck": "node node_modules/typescript/bin/tsc -p tsconfig.typecheck.json --noEmit",
     "generate": "node node_modules/typescript/bin/tsc -p tsconfig.generate.json && node .generate/generate/discovery.generate.js && prisma generate --schema src/discovery/__fixtures__/ignore.prisma",
-    "db:push": "prisma db push --config prisma.config.sqlite.ts && sh -c 'if [ -n \"$AVENTARA_TEST_POSTGRES_URL\" ]; then prisma db push --config prisma.config.postgres.ts; else echo \"AVENTARA_TEST_POSTGRES_URL is unset: skipping the PostgreSQL schema push\"; fi'",
-    "test": "pnpm run generate && pnpm run db:push && vitest run --typecheck --typecheck.checker node_modules/typescript/bin/tsc --no-file-parallelism --config vitest.config.mts --root .",
-    "test:sqlite": "pnpm run generate && prisma db push --config prisma.config.sqlite.ts && vitest run --config vitest.config.mts --root . src/environment.spec.ts",
+    "db:push": "prisma db push --config prisma.config.sqlite.ts && pnpm run db:push:postgres",
+    "db:push:postgres": "sh -c 'if [ -n \"$AVENTARA_TEST_POSTGRES_URL\" ]; then prisma db push --config prisma.config.postgres.ts; else echo \"AVENTARA_TEST_POSTGRES_URL is unset: skipping the PostgreSQL schema push\"; fi'",
+    "test": "pnpm run generate && pnpm run db:push:postgres && vitest run --typecheck --typecheck.checker node_modules/typescript/bin/tsc --no-file-parallelism --config vitest.config.mts --root .",
+    "test:sqlite": "pnpm run generate && vitest run --config vitest.config.mts --root . src/environment.spec.ts",
     "test:postgres": "pnpm run generate && prisma db push --config prisma.config.postgres.ts && vitest run --config vitest.config.mts --root . src/environment.spec.ts",
     "lint": "biome lint src"
   }