@shivaedev/effect-prisma 0.6.3 → 0.6.4

package/src/internal/relation-plan.ts

@@ -1,4 +1,4 @@
-import type { RelationRecipe } from "./recipe.js";
+import type { RelationRecipe } from "./recipe.ts";
 
 export interface RelationPlan {
 	readonly liveness: { readonly open: boolean };

package/src/internal/relation-result.ts

@@ -0,0 +1,27 @@
+import { Effect, Option } from "effect";
+import type { PrismaError } from "../error.ts";
+import { hasMethod, invokeMethod, isPromiseLike } from "./dynamic.ts";
+import { fromPrismaPromise } from "./promise.ts";
+
+const settle = (value: unknown, map: (result: unknown) => unknown): Effect.Effect<unknown, PrismaError> =>
+	isPromiseLike(value) ? fromPrismaPromise(() => value).pipe(Effect.map(map)) : Effect.succeed(map(value));
+
+const countOf = (result: unknown): unknown => (typeof result === "object" && result !== null ? Reflect.get(result, "count") : undefined);
+
+export const evaluateResult = (value: unknown, terminal: PropertyKey | undefined): Effect.Effect<unknown, PrismaError> => {
+	if (terminal === "count" && hasMethod(value, "aggregate")) {
+		return settle(invokeMethod(value, "aggregate", [(summary: { count(): unknown }) => ({ count: summary.count() })]), countOf);
+	}
+
+	if (terminal === "exists" && hasMethod(value, "first")) {
+		return settle(invokeMethod(value, "first", []), (result) => result !== null);
+	}
+
+	const executable = hasMethod(value, "all") ? invokeMethod(value, "all", []) : value;
+
+	if (isPromiseLike(executable)) {
+		return settle(executable, (result) => (terminal === "first" ? Option.fromNullishOr(result) : result));
+	}
+
+	return Effect.succeed(executable);
+};

package/src/internal/relation-runtime.ts

@@ -1,141 +1,54 @@
-import { Effect, Effectable, Option, type Stream } from "effect";
-import type { PrismaError } from "../error.js";
-import type { Relation } from "../relation.js";
-import type { AnyPostgresContract, DatabaseExecutor } from "./executor.js";
-import { fromPrismaPromise } from "./promise.js";
-import { executeQuery } from "./query-execution.js";
-import {
-	appendOperation,
-	type RelationRecipe,
-	replayRecipe,
-	rootRecipe,
-} from "./recipe.js";
-import { setRelationPlan } from "./relation-plan.js";
-import { makeRelationStream } from "./relation-stream.js";
+import { Effect, Effectable, type Stream } from "effect";
+import type { PrismaError } from "../error.ts";
+import type { Relation } from "../relation.ts";
+import type { AnyPostgresContract, DatabaseExecutor } from "./executor.ts";
+import { executeQuery } from "./query-execution.ts";
+import { appendOperation, type RelationRecipe, replayRecipe, rootRecipe } from "./recipe.ts";
+import { setRelationPlan } from "./relation-plan.ts";
+import { evaluateResult } from "./relation-result.ts";
+import { makeRelationStream } from "./relation-stream.ts";
 
-type AnyFunction = (...arguments_: ReadonlyArray<never>) => unknown;
-
-interface RelationRuntime<
-	Models extends object,
-	Contract extends AnyPostgresContract,
-> {
+interface RelationRuntime<Models extends object, Contract extends AnyPostgresContract> {
 	readonly executor: DatabaseExecutor<Models, Contract>;
 	readonly recipe: RelationRecipe;
-	readonly resolveExecutor: Effect.Effect<
-		DatabaseExecutor<Models, Contract>,
-		PrismaError
-	>;
+	readonly resolveExecutor: Effect.Effect<DatabaseExecutor<Models, Contract>, PrismaError>;
 	readonly terminal?: PropertyKey;
 }
 
-const evaluateResult = (
-	value: unknown,
-	terminal: PropertyKey | undefined,
-): Effect.Effect<unknown, PrismaError> => {
-	if (
-		terminal === "count" &&
-		typeof value === "object" &&
-		value !== null &&
-		typeof Reflect.get(value, "aggregate") === "function"
-	) {
-		const aggregate = Reflect.apply(
-			Reflect.get(value, "aggregate") as AnyFunction,
-			value,
-			[(summary: { count(): unknown }) => ({ count: summary.count() })],
-		);
-		return fromPrismaPromise(
-			() => aggregate as PromiseLike<{ count: number }>,
-		).pipe(Effect.map((result) => result.count));
-	}
-
-	if (
-		terminal === "exists" &&
-		typeof value === "object" &&
-		value !== null &&
-		typeof Reflect.get(value, "first") === "function"
-	) {
-		const first = Reflect.apply(
-			Reflect.get(value, "first") as AnyFunction,
-			value,
-			[],
-		);
-		return fromPrismaPromise(() => first as PromiseLike<unknown>).pipe(
-			Effect.map((result) => result !== null),
-		);
-	}
-
-	const executable =
-		typeof value === "object" &&
-		value !== null &&
-		typeof Reflect.get(value, "all") === "function"
-			? Reflect.apply(Reflect.get(value, "all") as AnyFunction, value, [])
-			: value;
-
-	if (
-		typeof executable === "object" &&
-		executable !== null &&
-		"then" in executable
-	) {
-		return fromPrismaPromise(() => executable as PromiseLike<unknown>).pipe(
-			Effect.map((result) =>
-				terminal === "first" ? Option.fromNullishOr(result) : result,
-			),
-		);
-	}
-
-	return Effect.succeed(executable);
-};
-
 interface RelationValue extends Effect.Effect<unknown, PrismaError> {
 	readonly stream: Stream.Stream<unknown, PrismaError>;
 }
 
-const runtimes = new WeakMap<object, unknown>();
+type AnyRelationRuntime = RelationRuntime<object, AnyPostgresContract>;
 
-const runtimeOf = <Models extends object, Contract extends AnyPostgresContract>(
-	self: object,
-): RelationRuntime<Models, Contract> => {
+const runtimes = new WeakMap<object, AnyRelationRuntime>();
+
+const runtimeOf = (self: object): AnyRelationRuntime => {
 	const runtime = runtimes.get(self);
 	if (runtime === undefined) {
 		throw new TypeError("Relation runtime is unavailable");
 	}
-	return runtime as RelationRuntime<Models, Contract>;
+	return runtime;
 };
 
-const relationEffect = <
-	Models extends object,
-	Contract extends AnyPostgresContract,
->(
-	self: RelationValue,
-): Effect.Effect<unknown, PrismaError> => {
-	const runtime = runtimeOf<Models, Contract>(self);
+const relationEffect = (self: object): Effect.Effect<unknown, PrismaError> => {
+	const runtime = runtimeOf(self);
 	return Effect.flatMap(runtime.resolveExecutor, (executor) =>
 		executeQuery(
 			executor,
 			Effect.suspend(() =>
-				evaluateResult(
-					replayRecipe(
-						executor.models,
-						runtime.recipe,
-						executor.identity,
-						executor.transactionIdentity,
-					),
-					runtime.terminal,
-				),
+				evaluateResult(replayRecipe(executor.models, runtime.recipe, executor.identity, executor.transactionIdentity), runtime.terminal),
 			),
 		),
 	).pipe(
-		Effect.withSpan(
-			`prisma.${runtime.recipe.model}.${String(runtime.terminal ?? "all")}`,
-			{
-				kind: "client",
-				attributes: {
-					"db.system": "postgresql",
-					"db.model": runtime.recipe.model,
-					"db.operation": String(runtime.terminal ?? "all"),
-				},
+		Effect.withSpan(`prisma.${runtime.recipe.model}.${String(runtime.terminal ?? "all")}`, {
+			kind: "client",
+			attributes: {
+				"db.system": "postgresql",
+				"db.model": runtime.recipe.model,
+				"db.operation": String(runtime.terminal ?? "all"),
 			},
-		),
+		}),
 	);
 };
 
@@ -147,21 +60,13 @@ const RelationPrototype = {
 		},
 	}),
 	get stream(): Stream.Stream<unknown, PrismaError> {
-		const relation = this as RelationValue;
-		const runtime = runtimeOf<Record<string, unknown>, AnyPostgresContract>(
-			relation,
-		);
+		const runtime = runtimeOf(this);
 		return makeRelationStream(runtime.resolveExecutor, runtime.recipe);
 	},
 };
 
-const makeRelationProxy = <
-	Models extends object,
-	Contract extends AnyPostgresContract,
->(
-	runtime: RelationRuntime<Models, Contract>,
-): unknown => {
-	const target = Object.create(RelationPrototype) as RelationValue;
+const makeRelationProxy = (runtime: AnyRelationRuntime): object => {
+	const target: object = Object.create(RelationPrototype);
 	const proxy = new Proxy(target, {
 		get(self, property, receiver) {
 			if (property === "then") {
@@ -206,6 +111,12 @@ const makeRelationProxy = <
 	return proxy;
 };
 
+// The proxy replays every Relation call onto the Prisma collection for `model`, so it has that collection's Relation surface.
+function asRelation<Collection, Model extends string>(proxy: object): Relation<Collection, undefined, Model>;
+function asRelation(proxy: object): unknown {
+	return proxy;
+}
+
 export const makeModelRelation = <
 	Collection,
 	Models extends object,
@@ -214,13 +125,12 @@ export const makeModelRelation = <
 >(
 	executor: DatabaseExecutor<Models, ExecutorContract>,
 	model: Model,
-	resolveExecutor: Effect.Effect<
-		DatabaseExecutor<Models, ExecutorContract>,
-		PrismaError
-	> = Effect.succeed(executor),
+	resolveExecutor: Effect.Effect<DatabaseExecutor<Models, ExecutorContract>, PrismaError> = Effect.succeed(executor),
 ): Relation<Collection, undefined, Model> =>
-	makeRelationProxy({
-		executor,
-		recipe: rootRecipe(model),
-		resolveExecutor,
-	}) as Relation<Collection, undefined, Model>;
+	asRelation<Collection, Model>(
+		makeRelationProxy({
+			executor,
+			recipe: rootRecipe(model),
+			resolveExecutor,
+		}),
+	);

package/src/internal/relation-stream.ts

@@ -1,20 +1,22 @@
 import { Effect, Stream } from "effect";
-import { isPrismaFailure, type PrismaError, toPrismaError } from "../error.js";
-import type { AnyPostgresContract, DatabaseExecutor } from "./executor.js";
-import { fromPrismaPromise } from "./promise.js";
-import { executeQuery } from "./query-execution.js";
-import { type RelationRecipe, replayRecipe } from "./recipe.js";
+import { isPrismaFailure, type PrismaError, toPrismaError } from "../error.ts";
+import { hasMethod, invokeMethod, isAsyncIterable } from "./dynamic.ts";
+import type { AnyPostgresContract, DatabaseExecutor } from "./executor.ts";
+import { fromPrismaPromise } from "./promise.ts";
+import { executeQuery } from "./query-execution.ts";
+import { type RelationRecipe, replayRecipe } from "./recipe.ts";
 
-type AnyFunction = (...arguments_: ReadonlyArray<never>) => unknown;
+const collectRows = (iterable: AsyncIterable<unknown>): Effect.Effect<Array<unknown>, PrismaError> =>
+	fromPrismaPromise(async () => {
+		const rows: Array<unknown> = [];
+		for await (const row of iterable) {
+			rows.push(row);
+		}
+		return rows;
+	});
 
-export const makeRelationStream = <
-	Models extends object,
-	Contract extends AnyPostgresContract,
->(
-	resolveExecutor: Effect.Effect<
-		DatabaseExecutor<Models, Contract>,
-		PrismaError
-	>,
+export const makeRelationStream = <Models extends object, Contract extends AnyPostgresContract>(
+	resolveExecutor: Effect.Effect<DatabaseExecutor<Models, Contract>, PrismaError>,
 	recipe: RelationRecipe,
 ): Stream.Stream<unknown, PrismaError> => {
 	return Stream.unwrap(
@@ -22,49 +24,21 @@ export const makeRelationStream = <
 			executeQuery(
 				executor,
 				Effect.sync(() => {
-					const collection = replayRecipe(
-						executor.models,
-						recipe,
-						executor.identity,
-						executor.transactionIdentity,
-					);
-					if (
-						typeof collection !== "object" ||
-						collection === null ||
-						typeof Reflect.get(collection, "all") !== "function"
-					) {
+					const collection = replayRecipe(executor.models, recipe, executor.identity, executor.transactionIdentity);
+					const iterable = hasMethod(collection, "all") ? invokeMethod(collection, "all", []) : undefined;
+					if (!isAsyncIterable(iterable)) {
 						throw new TypeError("Only collection Relations can be streamed");
 					}
-					const iterable = Reflect.apply(
-						Reflect.get(collection, "all") as AnyFunction,
-						collection,
-						[],
-					) as AsyncIterable<unknown>;
 
 					if (executor.mode === "root") {
 						return Stream.fromAsyncIterable(iterable, (error) => error).pipe(
-							Stream.catch((error) =>
-								isPrismaFailure(error)
-									? Stream.fail(toPrismaError(error))
-									: Stream.die(error),
-							),
+							Stream.catch((error) => (isPrismaFailure(error) ? Stream.fail(toPrismaError(error)) : Stream.die(error))),
 						);
 					}
 
-					const buffered = executeQuery(
-						executor,
-						fromPrismaPromise(async () => {
-							const rows: Array<unknown> = [];
-							for await (const row of iterable) {
-								rows.push(row);
-							}
-							return rows;
-						}),
-					);
+					const buffered = executeQuery(executor, collectRows(iterable));
 
-					return Stream.unwrap(
-						Effect.map(buffered, (rows) => Stream.fromIterable(rows)),
-					);
+					return Stream.unwrap(Effect.map(buffered, (rows) => Stream.fromIterable(rows)));
 				}),
 			),
 		),

package/src/internal/sqlite-datetime.ts

@@ -1,5 +1,5 @@
 import type { ExecutionContext } from "@prisma-next/sql-runtime";
-import type { AnySqlContract } from "./executor.js";
+import type { AnySqlContract } from "./executor.ts";
 
 type CodecRegistry = ExecutionContext<AnySqlContract>["contractCodecs"];
 type ContractCodec = ReturnType<CodecRegistry["forCodecRef"]>;
@@ -8,8 +8,7 @@ type CodecJson = Parameters<ContractCodec["decodeJson"]>[0];
 
 const sqliteDatetimeCodecId = "sqlite/datetime@1";
 
-const zonelessDatetime =
-	/^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?)$/;
+const zonelessDatetime = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?)$/;
 
 /**
  * Stamp `Z` onto a SQLite datetime string that carries no zone designator.
@@ -22,22 +21,14 @@ const zonelessDatetime =
  * `new Date` already reads as UTC), and anything that is not a datetime string
  * are returned unchanged.
  */
-export const normalizeSqliteDatetime = (value: string): string =>
-	value.replace(zonelessDatetime, "$1T$2Z");
+export const normalizeSqliteDatetime = (value: string): string => value.replace(zonelessDatetime, "$1T$2Z");
 
 const decodeAsUtc = (codec: ContractCodec): ContractCodec => ({
 	id: sqliteDatetimeCodecId,
 	encode: (value, context) => codec.encode(value, context),
-	decode: (wire: CodecWire, context) =>
-		codec.decode(
-			typeof wire === "string" ? normalizeSqliteDatetime(wire) : wire,
-			context,
-		),
+	decode: (wire: CodecWire, context) => codec.decode(typeof wire === "string" ? normalizeSqliteDatetime(wire) : wire, context),
 	encodeJson: (value) => codec.encodeJson(value),
-	decodeJson: (json: CodecJson) =>
-		codec.decodeJson(
-			typeof json === "string" ? normalizeSqliteDatetime(json) : json,
-		),
+	decodeJson: (json: CodecJson) => codec.decodeJson(typeof json === "string" ? normalizeSqliteDatetime(json) : json),
 });
 
 /**
@@ -55,9 +46,7 @@ const decodeAsUtc = (codec: ContractCodec): ContractCodec => ({
  * Prisma Next materializes a codec through an unbound descriptor factory, so
  * the instance's `id` accessor throws.
  */
-export const decodeSqliteDatetimesAsUtc = (
-	context: ExecutionContext<AnySqlContract>,
-): void => {
+export const decodeSqliteDatetimesAsUtc = (context: ExecutionContext<AnySqlContract>): void => {
 	const registry = context.contractCodecs;
 	const descriptors = context.codecDescriptors;
 	const utcCodecs = new WeakMap<ContractCodec, ContractCodec>();
@@ -78,11 +67,7 @@ export const decodeSqliteDatetimesAsUtc = (
 			if (codec === undefined) {
 				return undefined;
 			}
-			const reference = descriptors.codecRefForColumn(
-				namespaceId,
-				table,
-				column,
-			);
+			const reference = descriptors.codecRefForColumn(namespaceId, table, column);
 			return reference?.codecId === sqliteDatetimeCodecId ? wrap(codec) : codec;
 		},
 		forCodecRef: (reference) => {
@@ -91,5 +76,7 @@ export const decodeSqliteDatetimesAsUtc = (
 		},
 	};
 
-	(context as { contractCodecs: CodecRegistry }).contractCodecs = utcRegistry;
+	if (!Reflect.set(context, "contractCodecs", utcRegistry)) {
+		throw new TypeError("The SQLite execution context does not accept a codec registry");
+	}
 };

package/src/internal/sqlite-pragmas.ts

@@ -22,10 +22,7 @@ export const assertFileBackedPath = (path: string): void => {
  * it opens, but it has no hook for anything else, so durable pragmas such as
  * `journal_mode` are applied once against the database file itself.
  */
-export const applySqlitePragmas = (
-	path: string,
-	pragmas: ReadonlyArray<string>,
-): void => {
+export const applySqlitePragmas = (path: string, pragmas: ReadonlyArray<string>): void => {
 	if (pragmas.length === 0) {
 		return;
 	}

package/src/internal/testing.ts

@@ -1,9 +1,7 @@
 import type { Effect } from "effect";
-import type { PrismaError } from "../error.js";
+import type { PrismaError } from "../error.ts";
 
-export const DatabaseTestingTypeId: unique symbol = Symbol.for(
-	"@shivaedev/effect-prisma/DatabaseTesting",
-);
+export const DatabaseTestingTypeId: unique symbol = Symbol.for("@shivaedev/effect-prisma/DatabaseTesting");
 
 export interface DatabaseTesting<DatabaseId> {
 	readonly withTestTransaction: <A, E, R>(
@@ -15,18 +13,18 @@ export interface DatabaseWithTesting<DatabaseId> {
 	readonly [DatabaseTestingTypeId]: DatabaseTesting<DatabaseId>;
 }
 
-export const getDatabaseTesting = <DatabaseId>(
-	database: object,
-): DatabaseTesting<DatabaseId> => {
-	const testing = Reflect.get(database, DatabaseTestingTypeId) as
-		| DatabaseTesting<DatabaseId>
-		| undefined;
+// makeSqlDatabase installs the testing hooks for the database's own service identifier.
+function testingFor<DatabaseId>(testing: object): DatabaseTesting<DatabaseId>;
+function testingFor(testing: object): unknown {
+	return testing;
+}
 
-	if (testing === undefined) {
-		throw new TypeError(
-			"The database was not created by this copy of @shivaedev/effect-prisma",
-		);
+export const getDatabaseTesting = <DatabaseId>(database: object): DatabaseTesting<DatabaseId> => {
+	const testing: unknown = Reflect.get(database, DatabaseTestingTypeId);
+
+	if (typeof testing !== "object" || testing === null || typeof Reflect.get(testing, "withTestTransaction") !== "function") {
+		throw new TypeError("The database was not created by this copy of @shivaedev/effect-prisma");
 	}
 
-	return testing;
+	return testingFor<DatabaseId>(testing);
 };

package/src/internal/transaction.ts

@@ -1,45 +1,26 @@
 import { orm } from "@prisma-next/sql-orm-client";
-import type {
-	RuntimeConnection,
-	RuntimeTransaction,
-} from "@prisma-next/sql-runtime";
 import { Effect, Exit, Semaphore } from "effect";
-import type { PrismaError } from "../error.js";
-import type { AnySqlContract, DatabaseExecutor } from "./executor.js";
-import { fromPrismaPromise } from "./promise.js";
+import type { PrismaError } from "../error.ts";
+import { type SettledConnection, type SettledTransaction, settleConnection } from "./adapters/transaction-settlement.ts";
+import type { AnySqlContract, DatabaseExecutor } from "./executor.ts";
+import { fromPrismaPromise } from "./promise.ts";
 
-export type TransactionOrm<Contract extends AnySqlContract> = ReturnType<
-	typeof orm<Contract>
->;
+export type TransactionOrm<Contract extends AnySqlContract> = ReturnType<typeof orm<Contract>>;
 
 export const withTransactionSemaphore = <A, E, R>(
 	semaphore: Semaphore.Semaphore | undefined,
 	transaction: Effect.Effect<A, E, R>,
-): Effect.Effect<A, E, R> =>
-	semaphore === undefined ? transaction : semaphore.withPermit(transaction);
+): Effect.Effect<A, E, R> => (semaphore === undefined ? transaction : semaphore.withPermit(transaction));
 
-export interface TransactionResource<
-	Models extends object,
-	Contract extends AnySqlContract,
-> {
-	readonly connection: RuntimeConnection;
-	readonly transaction: RuntimeTransaction;
+export interface TransactionResource<Models extends object, Contract extends AnySqlContract> {
+	readonly connection: SettledConnection;
+	readonly transaction: SettledTransaction;
 	readonly executor: DatabaseExecutor<Models, Contract> & {
 		readonly querySemaphore: Semaphore.Semaphore;
 	};
 }
 
-const runtimeFailure = (
-	code: string,
-	cause: unknown,
-	details?: Readonly<Record<string, unknown>>,
-): Error & { readonly code: string } =>
-	Object.assign(new Error(code, { cause }), { code, ...details });
-
-export const acquireTransaction = <
-	Models extends object,
-	Contract extends AnySqlContract,
->(
+export const acquireTransaction = <Models extends object, Contract extends AnySqlContract>(
 	current: DatabaseExecutor<Models, Contract>,
 	models: (orm: TransactionOrm<Contract>) => Models,
 	mode: "test" | "transaction",
@@ -77,32 +58,17 @@ export const acquireTransaction = <
 		}
 	});
 
-export const releaseTransaction = <
-	Models extends object,
-	Contract extends AnySqlContract,
-	A,
-	E,
->(
+export const releaseTransaction = <Models extends object, Contract extends AnySqlContract, A, E>(
 	resource: TransactionResource<Models, Contract>,
 	exit: Exit.Exit<A, E>,
 ): Effect.Effect<void, PrismaError> => settleTransaction(resource, exit, true);
 
-export const releaseTestTransaction = <
-	Models extends object,
-	Contract extends AnySqlContract,
-	A,
-	E,
->(
+export const releaseTestTransaction = <Models extends object, Contract extends AnySqlContract, A, E>(
 	resource: TransactionResource<Models, Contract>,
 	exit: Exit.Exit<A, E>,
 ): Effect.Effect<void, PrismaError> => settleTransaction(resource, exit, false);
 
-const settleTransaction = <
-	Models extends object,
-	Contract extends AnySqlContract,
-	A,
-	E,
->(
+const settleTransaction = <Models extends object, Contract extends AnySqlContract, A, E>(
 	resource: TransactionResource<Models, Contract>,
 	exit: Exit.Exit<A, E>,
 	commitOnSuccess: boolean,
@@ -112,66 +78,7 @@ const settleTransaction = <
 			resource.executor.liveness.open = false;
 		}).pipe(
 			Effect.andThen(
-				resource.executor.querySemaphore.withPermit(
-					fromPrismaPromise(async () => {
-						let disposed = false;
-						let failure: unknown;
-
-						const destroy = async (reason: unknown): Promise<void> => {
-							if (disposed) {
-								return;
-							}
-							disposed = true;
-							await resource.connection.destroy(reason).catch(() => undefined);
-						};
-
-						if (commitOnSuccess && Exit.isSuccess(exit)) {
-							try {
-								await resource.transaction.commit();
-							} catch (commitError) {
-								try {
-									await resource.transaction.rollback();
-								} catch {
-									await destroy(commitError);
-								}
-								failure = runtimeFailure(
-									"RUNTIME.TRANSACTION_COMMIT_FAILED",
-									commitError,
-								);
-							}
-						} else {
-							try {
-								await resource.transaction.rollback();
-							} catch (rollbackError) {
-								await destroy(rollbackError);
-								failure = runtimeFailure(
-									"RUNTIME.TRANSACTION_ROLLBACK_FAILED",
-									rollbackError,
-								);
-							}
-						}
-
-						if (!disposed) {
-							try {
-								await resource.connection.release();
-							} catch (releaseError) {
-								await destroy(releaseError);
-								if (failure !== undefined) {
-									throw runtimeFailure(
-										"RUNTIME.TRANSACTION_RELEASE_FAILED",
-										failure,
-										{ releaseError },
-									);
-								}
-								throw releaseError;
-							}
-						}
-
-						if (failure !== undefined) {
-							throw failure;
-						}
-					}),
-				),
+				resource.executor.querySemaphore.withPermit(fromPrismaPromise(() => settleConnection(resource, commitOnSuccess && Exit.isSuccess(exit)))),
 			),
 		),
 	);