@shivaedev/effect-prisma 0.5.2 → 0.6.0

package/src/internal/relation-runtime.ts

@@ -1,12 +1,7 @@
-import type { Context } from "effect";
 import { Effect, Effectable, Option, type Stream } from "effect";
 import type { PrismaError } from "../error.js";
 import type { Relation } from "../relation.js";
-import type {
-	AnyPostgresContract,
-	DatabaseExecutor,
-	ExecutorIdentifier,
-} from "./executor.js";
+import type { AnyPostgresContract, DatabaseExecutor } from "./executor.js";
 import { fromPrismaPromise } from "./promise.js";
 import { executeQuery } from "./query-execution.js";
 import {
@@ -15,7 +10,7 @@ import {
 	replayRecipe,
 	rootRecipe,
 } from "./recipe.js";
-import { RelationPlanTypeId } from "./relation-plan.js";
+import { setRelationPlan } from "./relation-plan.js";
 import { makeRelationStream } from "./relation-stream.js";
 
 type AnyFunction = (...arguments_: ReadonlyArray<never>) => unknown;
@@ -24,11 +19,12 @@ interface RelationRuntime<
 	Models extends object,
 	Contract extends AnyPostgresContract,
 > {
-	readonly executor: Context.Service<
-		ExecutorIdentifier<Models>,
-		DatabaseExecutor<Models, Contract>
-	>;
+	readonly executor: DatabaseExecutor<Models, Contract>;
 	readonly recipe: RelationRecipe;
+	readonly resolveExecutor: Effect.Effect<
+		DatabaseExecutor<Models, Contract>,
+		PrismaError
+	>;
 	readonly terminal?: PropertyKey;
 }
 
@@ -90,74 +86,72 @@ const evaluateResult = (
 	return Effect.succeed(executable);
 };
 
-interface RelationValue<
-	Models extends object,
-	Contract extends AnyPostgresContract,
-> extends Effect.Effect<unknown, PrismaError, ExecutorIdentifier<Models>> {
-	readonly [RelationPlanTypeId]: {
-		readonly recipe: RelationRecipe;
-		readonly terminal?: PropertyKey;
-	};
-	readonly runtime: RelationRuntime<Models, Contract>;
-	readonly stream: Stream.Stream<
-		unknown,
-		PrismaError,
-		ExecutorIdentifier<Models>
-	>;
+interface RelationValue extends Effect.Effect<unknown, PrismaError> {
+	readonly stream: Stream.Stream<unknown, PrismaError>;
 }
 
+const runtimes = new WeakMap<object, unknown>();
+
+const runtimeOf = <Models extends object, Contract extends AnyPostgresContract>(
+	self: object,
+): RelationRuntime<Models, Contract> => {
+	const runtime = runtimes.get(self);
+	if (runtime === undefined) {
+		throw new TypeError("Relation runtime is unavailable");
+	}
+	return runtime as RelationRuntime<Models, Contract>;
+};
+
 const relationEffect = <
 	Models extends object,
 	Contract extends AnyPostgresContract,
 >(
-	self: RelationValue<Models, Contract>,
-): Effect.Effect<unknown, PrismaError, ExecutorIdentifier<Models>> =>
-	Effect.flatMap(self.runtime.executor, (executor) =>
+	self: RelationValue,
+): Effect.Effect<unknown, PrismaError> => {
+	const runtime = runtimeOf<Models, Contract>(self);
+	return Effect.flatMap(runtime.resolveExecutor, (executor) =>
 		executeQuery(
 			executor,
 			Effect.suspend(() =>
 				evaluateResult(
-					replayRecipe(executor.models, self.runtime.recipe),
-					self.runtime.terminal,
+					replayRecipe(
+						executor.models,
+						runtime.recipe,
+						executor.identity,
+						executor.transactionIdentity,
+					),
+					runtime.terminal,
 				),
 			),
 		),
 	).pipe(
 		Effect.withSpan(
-			`prisma.${self.runtime.recipe.model}.${String(self.runtime.terminal ?? "all")}`,
+			`prisma.${runtime.recipe.model}.${String(runtime.terminal ?? "all")}`,
 			{
 				kind: "client",
 				attributes: {
 					"db.system": "postgresql",
-					"db.model": self.runtime.recipe.model,
-					"db.operation": String(self.runtime.terminal ?? "all"),
+					"db.model": runtime.recipe.model,
+					"db.operation": String(runtime.terminal ?? "all"),
 				},
 			},
 		),
 	);
+};
 
 const RelationPrototype = {
-	...Effectable.Prototype<
-		RelationValue<Record<string, unknown>, AnyPostgresContract>
-	>({
+	...Effectable.Prototype<RelationValue>({
 		label: "EffectPrismaRelation",
 		evaluate() {
 			return relationEffect(this);
 		},
 	}),
-	get stream(): Stream.Stream<
-		unknown,
-		PrismaError,
-		ExecutorIdentifier<Record<string, unknown>>
-	> {
-		const relation = this as RelationValue<
-			Record<string, unknown>,
-			AnyPostgresContract
-		>;
-		return makeRelationStream(
-			relation.runtime.executor,
-			relation.runtime.recipe,
+	get stream(): Stream.Stream<unknown, PrismaError> {
+		const relation = this as RelationValue;
+		const runtime = runtimeOf<Record<string, unknown>, AnyPostgresContract>(
+			relation,
 		);
+		return makeRelationStream(runtime.resolveExecutor, runtime.recipe);
 	},
 };
 
@@ -167,15 +161,8 @@ const makeRelationProxy = <
 >(
 	runtime: RelationRuntime<Models, Contract>,
 ): unknown => {
-	const target = Object.assign(Object.create(RelationPrototype), {
-		[RelationPlanTypeId]: {
-			recipe: runtime.recipe,
-			...(runtime.terminal === undefined ? {} : { terminal: runtime.terminal }),
-		},
-		runtime,
-	}) as RelationValue<Models, Contract>;
-
-	return new Proxy(target, {
+	const target = Object.create(RelationPrototype) as RelationValue;
+	const proxy = new Proxy(target, {
 		get(self, property, receiver) {
 			if (property === "then") {
 				return undefined;
@@ -205,20 +192,35 @@ const makeRelationProxy = <
 				});
 		},
 	});
+	const plan = {
+		liveness: runtime.executor.liveness,
+		owner: runtime.executor.identity,
+		recipe: runtime.recipe,
+		...(runtime.terminal === undefined ? {} : { terminal: runtime.terminal }),
+		transactionIdentity: runtime.executor.transactionIdentity,
+	};
+	for (const value of [target, proxy]) {
+		runtimes.set(value, runtime);
+		setRelationPlan(value, plan);
+	}
+	return proxy;
 };
 
 export const makeModelRelation = <
 	Collection,
 	Models extends object,
-	Contract extends AnyPostgresContract = AnyPostgresContract,
+	ExecutorContract extends AnyPostgresContract = AnyPostgresContract,
+	Model extends string = string,
 >(
-	executor: Context.Service<
-		ExecutorIdentifier<Models>,
-		DatabaseExecutor<Models, Contract>
-	>,
-	model: string,
-): Relation<Collection, ExecutorIdentifier<Models>> =>
+	executor: DatabaseExecutor<Models, ExecutorContract>,
+	model: Model,
+	resolveExecutor: Effect.Effect<
+		DatabaseExecutor<Models, ExecutorContract>,
+		PrismaError
+	> = Effect.succeed(executor),
+): Relation<Collection, undefined, Model> =>
 	makeRelationProxy({
 		executor,
 		recipe: rootRecipe(model),
-	}) as Relation<Collection, ExecutorIdentifier<Models>>;
+		resolveExecutor,
+	}) as Relation<Collection, undefined, Model>;

package/src/internal/relation-stream.ts

@@ -1,11 +1,6 @@
-import type { Context } from "effect";
 import { Effect, Stream } from "effect";
 import { isPrismaFailure, type PrismaError, toPrismaError } from "../error.js";
-import type {
-	AnyPostgresContract,
-	DatabaseExecutor,
-	ExecutorIdentifier,
-} from "./executor.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";
@@ -16,51 +11,62 @@ export const makeRelationStream = <
 	Models extends object,
 	Contract extends AnyPostgresContract,
 >(
-	executorService: Context.Service<
-		ExecutorIdentifier<Models>,
-		DatabaseExecutor<Models, Contract>
+	resolveExecutor: Effect.Effect<
+		DatabaseExecutor<Models, Contract>,
+		PrismaError
 	>,
 	recipe: RelationRecipe,
-): Stream.Stream<unknown, PrismaError, ExecutorIdentifier<Models>> =>
-	Stream.unwrap(
-		Effect.map(executorService, (executor) => {
-			const collection = replayRecipe(executor.models, recipe);
-			if (
-				typeof collection !== "object" ||
-				collection === null ||
-				typeof Reflect.get(collection, "all") !== "function"
-			) {
-				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.querySemaphore === undefined) {
-				return Stream.fromAsyncIterable(iterable, (error) => error).pipe(
-					Stream.catch((error) =>
-						isPrismaFailure(error)
-							? Stream.fail(toPrismaError(error))
-							: Stream.die(error),
-					),
-				);
-			}
-
-			const buffered = executeQuery(
+): Stream.Stream<unknown, PrismaError> => {
+	return Stream.unwrap(
+		Effect.flatMap(resolveExecutor, (executor) =>
+			executeQuery(
 				executor,
-				fromPrismaPromise(async () => {
-					const rows: Array<unknown> = [];
-					for await (const row of iterable) {
-						rows.push(row);
+				Effect.sync(() => {
+					const collection = replayRecipe(
+						executor.models,
+						recipe,
+						executor.identity,
+						executor.transactionIdentity,
+					);
+					if (
+						typeof collection !== "object" ||
+						collection === null ||
+						typeof Reflect.get(collection, "all") !== "function"
+					) {
+						throw new TypeError("Only collection Relations can be streamed");
 					}
-					return rows;
-				}),
-			);
+					const iterable = Reflect.apply(
+						Reflect.get(collection, "all") as AnyFunction,
+						collection,
+						[],
+					) as AsyncIterable<unknown>;
 
-			return Stream.unwrap(
-				Effect.map(buffered, (rows) => Stream.fromIterable(rows)),
-			);
-		}),
+					if (executor.querySemaphore === undefined) {
+						return Stream.fromAsyncIterable(iterable, (error) => error).pipe(
+							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;
+						}),
+					);
+
+					return Stream.unwrap(
+						Effect.map(buffered, (rows) => Stream.fromIterable(rows)),
+					);
+				}),
+			),
+		),
 	);
+};

package/src/internal/testing.ts

@@ -5,21 +5,21 @@ export const DatabaseTestingTypeId: unique symbol = Symbol.for(
 	"@shivaedev/effect-prisma/DatabaseTesting",
 );
 
-export interface DatabaseTesting<Requirement> {
+export interface DatabaseTesting<DatabaseId> {
 	readonly withTestTransaction: <A, E, R>(
-		program: Effect.Effect<A, E, R>,
-	) => Effect.Effect<A, E | PrismaError, R | Requirement>;
+		program: Effect.Effect<A, E, R> & (DatabaseId extends R ? unknown : never),
+	) => Effect.Effect<A, E | PrismaError, DatabaseId | Exclude<R, DatabaseId>>;
 }
 
-export interface DatabaseWithTesting<Requirement> {
-	readonly [DatabaseTestingTypeId]: DatabaseTesting<Requirement>;
+export interface DatabaseWithTesting<DatabaseId> {
+	readonly [DatabaseTestingTypeId]: DatabaseTesting<DatabaseId>;
 }
 
-export const getDatabaseTesting = <Requirement>(
+export const getDatabaseTesting = <DatabaseId>(
 	database: object,
-): DatabaseTesting<Requirement> => {
+): DatabaseTesting<DatabaseId> => {
 	const testing = Reflect.get(database, DatabaseTestingTypeId) as
-		| DatabaseTesting<Requirement>
+		| DatabaseTesting<DatabaseId>
 		| undefined;
 
 	if (testing === undefined) {

package/src/internal/transaction.ts

@@ -12,13 +12,21 @@ 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);
+
 export interface TransactionResource<
 	Models extends object,
 	Contract extends AnySqlContract,
 > {
 	readonly connection: RuntimeConnection;
 	readonly transaction: RuntimeTransaction;
-	readonly executor: DatabaseExecutor<Models, Contract>;
+	readonly executor: DatabaseExecutor<Models, Contract> & {
+		readonly querySemaphore: Semaphore.Semaphore;
+	};
 }
 
 const runtimeFailure = (
@@ -34,6 +42,7 @@ export const acquireTransaction = <
 >(
 	current: DatabaseExecutor<Models, Contract>,
 	models: (orm: TransactionOrm<Contract>) => Models,
+	mode: "test" | "transaction",
 ): Effect.Effect<TransactionResource<Models, Contract>, PrismaError> =>
 	fromPrismaPromise(async () => {
 		const connection = await current.client.runtime().connection();
@@ -50,9 +59,16 @@ export const acquireTransaction = <
 				transaction,
 				executor: {
 					client: current.client,
+					identity: current.identity,
+					liveness: {
+						closedCode: "RUNTIME.TRANSACTION_CLOSED",
+						open: true,
+					},
+					mode,
 					models: models(transactionOrm),
 					querySemaphore: Semaphore.makeUnsafe(1),
-					transactional: true,
+					transactionIdentity: {},
+					transactionSemaphore: current.transactionSemaphore,
 				},
 			};
 		} catch (error) {
@@ -92,62 +108,70 @@ const settleTransaction = <
 	commitOnSuccess: boolean,
 ): Effect.Effect<void, PrismaError> =>
 	Effect.uninterruptible(
-		fromPrismaPromise(async () => {
-			let disposed = false;
-			let failure: unknown;
+		Effect.sync(() => {
+			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);
-			};
+						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 (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 (!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;
-			}
-		}),
+						if (failure !== undefined) {
+							throw failure;
+						}
+					}),
+				),
+			),
+		),
 	);

package/src/internal/vitest-database.ts

@@ -5,7 +5,6 @@ import * as TestConsole from "effect/testing/TestConsole";
 import { withTestTransaction } from "../testing/transaction.js";
 import type {
 	AnyDatabase,
-	DatabaseRequirement,
 	DatabaseService,
 	DatabaseTest,
 	DatabaseTester,
@@ -76,18 +75,10 @@ const restoreContext = <Provided>(
 	}) as DatabaseFixture<Provided>;
 
 export const makeDatabaseTester = <Database extends AnyDatabase, Provided>(
-	fixtureIt: FixtureTestApi<
-		Provided | DatabaseRequirement<Database> | Effect.Services<Database>
-	>,
+	fixtureIt: FixtureTestApi<Provided | Effect.Services<Database>>,
 	database: Database,
-): DatabaseTester<
-	Database,
-	Provided | DatabaseRequirement<Database> | Effect.Services<Database>
-> => {
-	type Services =
-		| Provided
-		| DatabaseRequirement<Database>
-		| Effect.Services<Database>;
+): DatabaseTester<Database, Provided | Effect.Services<Database>> => {
+	type Services = Provided | Effect.Services<Database>;
 
 	const run = <A, Eff extends Effect.Effect<unknown, unknown, Services>>(
 		body: (

package/src/relation/include.ts

@@ -16,9 +16,9 @@ type Simplify<Value> = { [Key in keyof Value]: Value[Key] };
 type QueryValue<Query> =
 	Query extends RelationQuery<
 		infer Value,
-		infer _Requirement,
 		infer _Contract,
-		infer _Model
+		infer _Model,
+		infer _DatabaseId
 	>
 		? Value
 		: never;
@@ -27,21 +27,27 @@ type AcceptRelatedQuery<
 	Query,
 	Contract extends AnyPostgresContract,
 	Model extends string,
-> =
-	Query extends RelationQuery<
+	DatabaseId,
+> = [Query] extends [
+	RelationQuery<
 		infer _Value,
-		infer _Requirement,
 		infer QueryContract,
-		infer QueryModel
-	>
-		? [QueryContract] extends [Contract]
-			? [Contract] extends [QueryContract]
-				? QueryModel extends Model
-					? unknown
+		infer QueryModel,
+		infer QueryDatabaseId
+	>,
+]
+	? [QueryContract] extends [Contract]
+		? [Contract] extends [QueryContract]
+			? [QueryDatabaseId] extends [DatabaseId]
+				? [DatabaseId] extends [QueryDatabaseId]
+					? QueryModel extends Model
+						? unknown
+						: never
 					: never
 				: never
 			: never
-		: never;
+		: never
+	: never;
 
 type IncludedQueryValue<
 	Query,
@@ -61,9 +67,10 @@ type AcceptRelatedQueryShape<
 	Shape extends Readonly<Record<string, unknown>>,
 	Contract extends AnyPostgresContract,
 	Model extends string,
+	DatabaseId,
 > = {
 	readonly [Key in keyof Shape]: Shape[Key] &
-		AcceptRelatedQuery<Shape[Key], Contract, Model>;
+		AcceptRelatedQuery<Shape[Key], Contract, Model, DatabaseId>;
 };
 
 type WithIncludedRelation<
@@ -84,9 +91,9 @@ type WithIncludedRelation<
 
 export type IncludeMethod<
 	Collection,
-	Requirement,
 	Contract,
 	Model extends string,
+	DatabaseId,
 > = Contract extends AnyPostgresContract
 	? Collection extends PrismaCollection<
 			Contract,
@@ -113,9 +120,9 @@ export type IncludeMethod<
 							>
 						>
 					>,
-					Requirement,
 					Contract,
-					Model
+					Model,
+					DatabaseId
 				>;
 				include<RelationName extends RelationNames<Contract, Model>, Query>(
 					relationName: RelationName,
@@ -123,7 +130,8 @@ export type IncludeMethod<
 						AcceptRelatedQuery<
 							Query,
 							Contract,
-							RelatedModelNameOf<Contract, Model, RelationName>
+							RelatedModelNameOf<Contract, Model, RelationName>,
+							DatabaseId
 						>,
 				): Relation<
 					WithIncludedRelation<
@@ -133,9 +141,9 @@ export type IncludeMethod<
 						RelationName,
 						IncludedQueryValue<Query, Contract, Model, RelationName>
 					>,
-					Requirement,
 					Contract,
-					Model
+					Model,
+					DatabaseId
 				>;
 				include<
 					RelationName extends RelationNames<Contract, Model>,
@@ -149,7 +157,8 @@ export type IncludeMethod<
 									AcceptRelatedQueryShape<
 										Shape,
 										Contract,
-										RelatedModelNameOf<Contract, Model, RelationName>
+										RelatedModelNameOf<Contract, Model, RelationName>,
+										DatabaseId
 									>
 						: never,
 				): Relation<
@@ -160,9 +169,9 @@ export type IncludeMethod<
 						RelationName,
 						QueryShapeValue<Shape>
 					>,
-					Requirement,
 					Contract,
-					Model
+					Model,
+					DatabaseId
 				>;
 			}
 		: Record<never, never>