@shivaedev/effect-prisma 0.5.3 → 0.6.0

package/src/internal/database-factory.ts

@@ -1,13 +1,9 @@
 import type { orm } from "@prisma-next/sql-orm-client";
 import { Context, Effect, Layer } from "effect";
-import type { PrismaError } from "../error.js";
+import { type PrismaError, toPrismaError } from "../error.js";
 import type { Relation } from "../relation.js";
 import { assertAvailableModelNames } from "./client-lifecycle.js";
-import type {
-	AnySqlContract,
-	DatabaseExecutor,
-	ExecutorIdentifier,
-} from "./executor.js";
+import type { AnySqlContract, DatabaseExecutor } from "./executor.js";
 import { makeModelRelation } from "./relation-runtime.js";
 import { DatabaseTestingTypeId } from "./testing.js";
 import {
@@ -15,6 +11,7 @@ import {
 	releaseTestTransaction,
 	releaseTransaction,
 	type TransactionOrm,
+	withTransactionSemaphore,
 } from "./transaction.js";
 
 type OrmFor<Contract extends AnySqlContract> = ReturnType<typeof orm<Contract>>;
@@ -30,27 +27,62 @@ export type DefaultModels<Contract extends AnySqlContract> =
 		? Models
 		: never;
 
-export interface DatabaseIdentifier<Contract extends AnySqlContract> {
-	readonly _contract: Contract;
-	readonly _databaseIdentifier: unique symbol;
+type IsUnion<Value, Whole = Value> = Value extends unknown
+	? [Whole] extends [Value]
+		? false
+		: true
+	: never;
+
+type IsSingletonString<Value extends string> =
+	Record<never, never> extends Record<Value, never> ? false : true;
+
+const internalContextIdentifierPrefix = "\0@shivaedev/effect-prisma/internal/";
+let activeTransactionReferenceSequence = 0;
+
+export type DatabaseIdentifierLiteral<Identifier extends string> = [
+	Identifier,
+] extends [`\0@shivaedev/effect-prisma/internal/${string}`]
+	? never
+	: string extends Identifier
+		? never
+		: true extends IsUnion<Identifier>
+			? never
+			: IsSingletonString<Identifier> extends true
+				? Identifier
+				: never;
+
+export interface DatabaseIdentifier<
+	Contract extends AnySqlContract,
+	Identifier extends string,
+> {
+	readonly _contract: (contract: Contract) => Contract;
+	readonly _databaseIdentifier: (identifier: Identifier) => Identifier;
 }
 
-type DatabaseModels<Contract extends AnySqlContract, Requirement> = {
+type DatabaseModels<
+	Contract extends AnySqlContract,
+	Identifier extends string,
+> = {
 	readonly [Model in keyof DefaultModels<Contract>]: Relation<
 		DefaultModels<Contract>[Model],
-		Requirement,
 		Contract,
-		Model & string
+		Model & string,
+		DatabaseIdentifier<Contract, Identifier>
 	>;
 };
 
 export type DatabaseService<
 	Contract extends AnySqlContract,
-	Requirement,
-> = DatabaseModels<Contract, Requirement> & {
+	Identifier extends string,
+> = DatabaseModels<Contract, Identifier> & {
 	transaction<A, E, R>(
-		program: Effect.Effect<A, E, R>,
-	): Effect.Effect<A, E | PrismaError, R | Requirement>;
+		program: Effect.Effect<A, E, R> &
+			(DatabaseIdentifier<Contract, Identifier> extends R ? unknown : never),
+	): Effect.Effect<
+		A,
+		E | PrismaError,
+		Exclude<R, DatabaseIdentifier<Contract, Identifier>>
+	>;
 };
 
 /**
@@ -59,41 +91,27 @@ export type DatabaseService<
  */
 export interface DatabaseServiceHolder<
 	Contract extends AnySqlContract,
-	Requirement = ExecutorIdentifier<DefaultModels<Contract>>,
+	Identifier extends string,
 > extends Context.Service<
-		DatabaseIdentifier<Contract>,
-		DatabaseService<Contract, Requirement>
+		DatabaseIdentifier<Contract, Identifier>,
+		DatabaseService<Contract, Identifier>
 	> {}
 
 export type AnyDatabase = Effect.Effect<unknown, never, unknown> & {
 	readonly layer: (...arguments_: ReadonlyArray<never>) => Layer.Any;
 };
 
-/**
- * `Context.Service` is invariant in both of its parameters, so a holder built
- * for a concrete contract never matches `DatabaseServiceHolder<AnySqlContract,
- * …>`. The contract has to be inferred alongside the requirement, or the
- * conditional falls through to `never` for every real database.
- */
-export type DatabaseRequirement<Database> =
-	Database extends DatabaseServiceHolder<
-		infer _Contract extends AnySqlContract,
-		infer Requirement
-	>
-		? Requirement
-		: never;
-
 export type DatabaseServiceOf<Database extends AnyDatabase> =
 	Effect.Success<Database>;
 
-export interface SqlDatabase<Contract extends AnySqlContract, Options>
-	extends DatabaseServiceHolder<Contract> {
+export interface SqlDatabase<
+	Contract extends AnySqlContract,
+	Identifier extends string,
+	Options,
+> extends DatabaseServiceHolder<Contract, Identifier> {
 	readonly layer: (
 		options: Options,
-	) => Layer.Layer<
-		DatabaseIdentifier<Contract> | ExecutorIdentifier<DefaultModels<Contract>>,
-		PrismaError
-	>;
+	) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
 }
 
 /**
@@ -121,68 +139,157 @@ export const namespaceModels = <
 };
 
 /**
- * Assemble the database service, its Executor service, and its Layer around a
- * driver-specific executor acquisition.
+ * Assemble the database service and its Layer around a driver-specific
+ * executor acquisition.
  */
-export const makeSqlDatabase = <const Contract extends AnySqlContract, Options>(
-	identifier: string,
+export const makeSqlDatabase = <
+	const Contract extends AnySqlContract,
+	const Identifier extends string,
+	Options,
+>(
+	identifier: DatabaseIdentifierLiteral<Identifier>,
 	acquireExecutor: (
 		options: Options,
 	) => Effect.Effect<
 		DatabaseExecutor<DefaultModels<Contract>, Contract>,
 		PrismaError
 	>,
-): SqlDatabase<Contract, Options> => {
+): SqlDatabase<Contract, Identifier, Options> => {
+	if (identifier.startsWith(internalContextIdentifierPrefix)) {
+		throw new TypeError(
+			"Database identifier uses a reserved internal namespace",
+		);
+	}
 	type Models = DefaultModels<Contract>;
-	type ExecutorId = ExecutorIdentifier<Models>;
-	type DatabaseId = DatabaseIdentifier<Contract>;
+	type DatabaseId = DatabaseIdentifier<Contract, Identifier>;
 
-	const Executor = Context.Service<
-		ExecutorId,
-		DatabaseExecutor<Models, Contract>
-	>(`${identifier}/Executor`);
 	const Service = Context.Service<
 		DatabaseId,
-		DatabaseService<Contract, ExecutorId>
+		DatabaseService<Contract, Identifier>
 	>(identifier);
+	const executors = new WeakMap<
+		DatabaseService<Contract, Identifier>,
+		DatabaseExecutor<Models, Contract>
+	>();
+	type ActiveTransaction = {
+		readonly executor: DatabaseExecutor<Models, Contract>;
+		readonly facade: DatabaseService<Contract, Identifier>;
+	};
+	const ActiveTransaction = Context.Reference<ActiveTransaction | undefined>(
+		`${internalContextIdentifierPrefix}ActiveTransaction/${activeTransactionReferenceSequence++}`,
+		{ defaultValue: () => undefined },
+	);
+	const executorOf = (
+		facade: DatabaseService<Contract, Identifier>,
+	): Effect.Effect<DatabaseExecutor<Models, Contract>> => {
+		const executor = executors.get(facade);
+		return executor === undefined
+			? Effect.die(
+					new TypeError(
+						"The database service was not created by its database Layer",
+					),
+				)
+			: Effect.succeed(executor);
+	};
+	const runTransaction = <A, E, R>(
+		current: DatabaseExecutor<Models, Contract>,
+		currentFacade: DatabaseService<Contract, Identifier>,
+		program: Effect.Effect<A, E, R>,
+		release: typeof releaseTransaction,
+		mode: "test" | "transaction",
+		span: string,
+	): Effect.Effect<A, E | PrismaError, Exclude<R, DatabaseId>> => {
+		if (!current.liveness.open) {
+			return Effect.fail(toPrismaError({ code: current.liveness.closedCode }));
+		}
+		if (
+			current.mode === "test" ||
+			(current.mode === "transaction" && mode === "transaction")
+		) {
+			return Effect.provideService(program, Service, currentFacade);
+		}
+		if (current.mode === "transaction") {
+			return Effect.fail(
+				toPrismaError({
+					code: "RUNTIME.TEST_TRANSACTION_INSIDE_TRANSACTION_UNSUPPORTED",
+				}),
+			);
+		}
 
-	const scopedTransaction =
-		(release: typeof releaseTransaction, span: string) =>
-		<A, E, R>(
-			program: Effect.Effect<A, E, R>,
-		): Effect.Effect<A, E | PrismaError, R | ExecutorId> =>
-			Effect.flatMap(Executor, (current) => {
-				if (current.transactional) {
-					return program;
-				}
-
-				return Effect.acquireUseRelease(
-					acquireTransaction(current, (transactionOrm) =>
-						namespaceModels<Contract, Models>(
-							current.client.contract,
-							transactionOrm,
-						),
+		const transaction = Effect.acquireUseRelease(
+			acquireTransaction(
+				current,
+				(transactionOrm) =>
+					namespaceModels<Contract, Models>(
+						current.client.contract,
+						transactionOrm,
 					),
-					(resource) =>
-						program.pipe(Effect.provideService(Executor, resource.executor)),
-					release,
-				).pipe(Effect.withSpan(span, { kind: "client" }));
-			});
-
-	const transaction = scopedTransaction(
-		releaseTransaction,
-		"prisma.transaction",
-	);
-	const withTestTransaction = scopedTransaction(
-		releaseTestTransaction,
-		"prisma.testTransaction",
-	);
+				mode,
+			),
+			(resource) => {
+				const transactionFacade = makeFacade(resource.executor);
+				return program.pipe(
+					Effect.provideService(Service, transactionFacade),
+					Effect.provideService(ActiveTransaction, {
+						executor: resource.executor,
+						facade: transactionFacade,
+					}),
+				);
+			},
+			release,
+		).pipe(Effect.withSpan(span, { kind: "client" }));
+
+		return withTransactionSemaphore(current.transactionSemaphore, transaction);
+	};
 
-	const facade = new Proxy(
-		Object.assign(Object.create(null), {
-			transaction,
-		}) as DatabaseService<Contract, ExecutorId>,
-		{
+	function makeFacade(
+		current: DatabaseExecutor<Models, Contract>,
+	): DatabaseService<Contract, Identifier> {
+		let facade: DatabaseService<Contract, Identifier>;
+		const resolveActiveTransaction = Effect.flatMap(
+			ActiveTransaction,
+			(active) => {
+				if (current.mode === "root") {
+					return Effect.succeed(active ?? { executor: current, facade });
+				}
+				return active?.executor === current
+					? Effect.succeed(active)
+					: Effect.fail(
+							toPrismaError({
+								code: "RUNTIME.TRANSACTION_CONTEXT_MISMATCH",
+							}),
+						);
+			},
+		);
+		const resolveExecutor = Effect.suspend(() =>
+			current.liveness.open
+				? Effect.map(resolveActiveTransaction, ({ executor }) => executor)
+				: Effect.succeed(current),
+		);
+		const target = Object.assign(Object.create(null), {
+			transaction: <A, E, R>(
+				program: Effect.Effect<A, E, R> &
+					(DatabaseId extends R ? unknown : never),
+			) =>
+				Effect.suspend(() => {
+					if (!current.liveness.open) {
+						return Effect.fail(
+							toPrismaError({ code: current.liveness.closedCode }),
+						);
+					}
+					return Effect.flatMap(resolveActiveTransaction, (selected) => {
+						return runTransaction(
+							selected.executor,
+							selected.facade,
+							program,
+							releaseTransaction,
+							"transaction",
+							"prisma.transaction",
+						);
+					});
+				}),
+		}) as DatabaseService<Contract, Identifier>;
+		facade = new Proxy(target, {
 			get(target, property, receiver) {
 				if (Reflect.has(target, property)) {
 					return Reflect.get(target, property, receiver);
@@ -190,29 +297,45 @@ export const makeSqlDatabase = <const Contract extends AnySqlContract, Options>(
 				if (typeof property !== "string") {
 					return undefined;
 				}
-				return makeModelRelation(Executor, property);
+				return makeModelRelation(current, property, resolveExecutor);
 			},
-		},
-	);
+		});
+		executors.set(facade, current);
+		return facade;
+	}
+
+	const withTestTransaction = <A, E, R>(
+		program: Effect.Effect<A, E, R> & (DatabaseId extends R ? unknown : never),
+	): Effect.Effect<A, E | PrismaError, DatabaseId | Exclude<R, DatabaseId>> =>
+		Effect.flatMap(Service, (facade) => {
+			return Effect.flatMap(executorOf(facade), (current) =>
+				runTransaction(
+					current,
+					facade,
+					program,
+					releaseTestTransaction,
+					"test",
+					"prisma.testTransaction",
+				),
+			);
+		});
 
 	const layer = (
 		layerOptions: Options,
-	): Layer.Layer<DatabaseId | ExecutorId, PrismaError> => {
+	): Layer.Layer<DatabaseId, PrismaError> => {
 		const acquire = Effect.acquireRelease(
 			Effect.suspend(() => acquireExecutor(layerOptions)),
-			(executor) =>
-				Effect.promise(() => executor.client.close()).pipe(Effect.orDie),
+			(executor) => {
+				executor.liveness.open = false;
+				return Effect.promise(() => executor.client.close()).pipe(Effect.orDie);
+			},
 		);
 
-		return Layer.effectContext(
-			Effect.map(acquire, (executor) =>
-				Context.make(Executor, executor).pipe(Context.add(Service, facade)),
-			),
-		);
+		return Layer.effect(Service)(Effect.map(acquire, makeFacade));
 	};
 
 	return Object.assign(Service, {
 		layer,
 		[DatabaseTestingTypeId]: { withTestTransaction },
-	}) as SqlDatabase<Contract, Options>;
+	}) as SqlDatabase<Contract, Identifier, Options>;
 };

package/src/internal/executor.ts

@@ -1,7 +1,7 @@
 import type { Contract as PrismaContract } from "@prisma-next/contract/types";
 import type { SqlStorage } from "@prisma-next/sql-contract/types";
 import type { ExecutionContext, Runtime } from "@prisma-next/sql-runtime";
-import type { Context, Semaphore } from "effect";
+import type { Semaphore } from "effect";
 
 export type AnySqlContract = PrismaContract<SqlStorage>;
 export type AnyPostgresContract = AnySqlContract;
@@ -22,20 +22,14 @@ export interface DatabaseExecutor<
 	Contract extends AnySqlContract = AnySqlContract,
 > {
 	readonly client: SqlDatabaseClient<Contract>;
+	readonly identity: object;
+	readonly liveness: {
+		readonly closedCode: string;
+		open: boolean;
+	};
+	readonly mode: "root" | "test" | "transaction";
 	readonly models: Models;
 	readonly querySemaphore: Semaphore.Semaphore | undefined;
-	readonly transactional: boolean;
-}
-
-export type ExecutorService<
-	Models extends object,
-	Contract extends AnySqlContract = AnySqlContract,
-> = Context.Service<
-	ExecutorIdentifier<Models>,
-	DatabaseExecutor<Models, Contract>
->;
-
-export interface ExecutorIdentifier<Models extends object> {
-	readonly _models: Models;
-	readonly _executorIdentifier: unique symbol;
+	readonly transactionIdentity: object | undefined;
+	readonly transactionSemaphore: Semaphore.Semaphore | undefined;
 }

package/src/internal/query-execution.ts

@@ -1,10 +1,18 @@
-import type { Semaphore } from "effect";
 import { Effect } from "effect";
+import { type PrismaError, toPrismaError } from "../error.js";
+import type { DatabaseExecutor } from "./executor.js";
 
 export const executeQuery = <A, E, R>(
-	executor: { readonly querySemaphore: Semaphore.Semaphore | undefined },
+	executor: Pick<DatabaseExecutor<object>, "liveness" | "querySemaphore">,
 	effect: Effect.Effect<A, E, R>,
-): Effect.Effect<A, E, R> =>
-	executor.querySemaphore === undefined
-		? effect
-		: executor.querySemaphore.withPermit(Effect.uninterruptible(effect));
+): Effect.Effect<A, E | PrismaError, R> => {
+	const checked = Effect.suspend(
+		(): Effect.Effect<A, E | PrismaError, R> =>
+			executor.liveness.open
+				? effect
+				: Effect.fail(toPrismaError({ code: executor.liveness.closedCode })),
+	);
+	return executor.querySemaphore === undefined
+		? checked
+		: executor.querySemaphore.withPermit(Effect.uninterruptible(checked));
+};

package/src/internal/recipe.ts

@@ -62,7 +62,24 @@ const applyMethod = (
 	return Reflect.apply(method, current, arguments_);
 };
 
-const replayPlan = (collection: unknown, plan: RelationPlan): unknown => {
+const replayPlan = (
+	collection: unknown,
+	plan: RelationPlan,
+	owner: object,
+	transactionIdentity: object | undefined,
+): unknown => {
+	if (!plan.liveness.open) {
+		throw new TypeError("Included Relation is closed");
+	}
+	if (plan.owner !== owner) {
+		throw new TypeError("Included Relations must use the same Database");
+	}
+	if (
+		plan.transactionIdentity !== undefined &&
+		plan.transactionIdentity !== transactionIdentity
+	) {
+		throw new TypeError("Included Relation belongs to another transaction");
+	}
 	const relatedModel =
 		typeof collection === "object" && collection !== null
 			? Reflect.get(collection, "modelName")
@@ -73,7 +90,12 @@ const replayPlan = (collection: unknown, plan: RelationPlan): unknown => {
 		);
 	}
 
-	const refined = replayRecipeFrom(collection, plan.recipe);
+	const refined = replayRecipeFrom(
+		collection,
+		plan.recipe,
+		owner,
+		transactionIdentity,
+	);
 	if (plan.terminal !== "count") {
 		return refined;
 	}
@@ -82,10 +104,13 @@ const replayPlan = (collection: unknown, plan: RelationPlan): unknown => {
 
 const includeRefinement = (
 	value: unknown,
+	owner: object,
+	transactionIdentity: object | undefined,
 ): ((collection: unknown) => unknown) => {
 	const plan = getRelationPlan(value);
 	if (plan !== undefined) {
-		return (collection) => replayPlan(collection, plan);
+		return (collection) =>
+			replayPlan(collection, plan, owner, transactionIdentity);
 	}
 
 	if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -115,19 +140,31 @@ const includeRefinement = (
 		const branches = Object.fromEntries(
 			plans.map(([name, queryPlan]) => [
 				name,
-				replayPlan(collection, queryPlan),
+				replayPlan(collection, queryPlan, owner, transactionIdentity),
 			]),
 		);
 		return applyMethod(collection, "combine", [branches], model ?? "relation");
 	};
 };
 
-const replayRecipeFrom = (root: unknown, recipe: RelationRecipe): unknown => {
+const replayRecipeFrom = (
+	root: unknown,
+	recipe: RelationRecipe,
+	owner: object,
+	transactionIdentity: object | undefined,
+): unknown => {
 	let current = root;
 	for (const operation of operations(recipe)) {
 		const arguments_ =
 			operation.name === "include" && operation.arguments.length === 2
-				? [operation.arguments[0], includeRefinement(operation.arguments[1])]
+				? [
+						operation.arguments[0],
+						includeRefinement(
+							operation.arguments[1],
+							owner,
+							transactionIdentity,
+						),
+					]
 				: operation.arguments;
 		current = applyMethod(current, operation.name, arguments_, recipe.model);
 	}
@@ -137,6 +174,8 @@ const replayRecipeFrom = (root: unknown, recipe: RelationRecipe): unknown => {
 export const replayRecipe = (
 	models: object,
 	recipe: RelationRecipe,
+	owner: object,
+	transactionIdentity: object | undefined,
 ): unknown => {
 	const current: unknown = Reflect.get(models, recipe.model);
 
@@ -144,5 +183,5 @@ export const replayRecipe = (
 		throw new TypeError(`Unknown Prisma model: ${recipe.model}`);
 	}
 
-	return replayRecipeFrom(current, recipe);
+	return replayRecipeFrom(current, recipe, owner, transactionIdentity);
 };

package/src/internal/relation-plan.ts

@@ -1,22 +1,22 @@
 import type { RelationRecipe } from "./recipe.js";
 
-export const RelationPlanTypeId = Symbol.for(
-	"@shivaedev/effect-prisma/RelationPlan",
-);
-
 export interface RelationPlan {
+	readonly liveness: { readonly open: boolean };
+	readonly owner: object;
 	readonly recipe: RelationRecipe;
 	readonly terminal?: PropertyKey;
+	readonly transactionIdentity: object | undefined;
 }
 
+const plans = new WeakMap<object, RelationPlan>();
+
+export const setRelationPlan = (value: object, plan: RelationPlan): void => {
+	plans.set(value, plan);
+};
+
 export const getRelationPlan = (value: unknown): RelationPlan | undefined => {
-	if (
-		typeof value !== "object" ||
-		value === null ||
-		!Reflect.has(value, RelationPlanTypeId)
-	) {
+	if (typeof value !== "object" || value === null) {
 		return undefined;
 	}
-
-	return Reflect.get(value, RelationPlanTypeId) as RelationPlan;
+	return plans.get(value);
 };