@shivaedev/effect-prisma 0.8.0 → 0.9.0

package/src/database.ts

@@ -12,9 +12,9 @@ export interface DatabaseLayerOptions extends PostgresOptionsBase {
 	readonly url: string | Redacted.Redacted<string>;
 }
 
-type DatabaseFactoryOptions<Contract extends AnySqlContract> =
+type DatabaseFactoryOptions<TContract extends AnySqlContract> =
 	| {
-			readonly contract: Contract;
+			readonly contract: TContract;
 			readonly contractJson?: never;
 	  }
 	| {
@@ -22,38 +22,44 @@ type DatabaseFactoryOptions<Contract extends AnySqlContract> =
 			readonly contract?: never;
 	  };
 
-export interface DatabaseDefinition<Contract extends AnySqlContract, Identifier extends string> extends DatabaseServiceHolder<Contract, Identifier> {
-	readonly layer: (options: DatabaseLayerOptions) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
+export interface DatabaseDefinition<TContract extends AnySqlContract, TIdentifier extends string>
+	extends DatabaseServiceHolder<TContract, TIdentifier> {
+	readonly layer: (options: DatabaseLayerOptions) => Layer.Layer<DatabaseIdentifier<TContract, TIdentifier>, PrismaError>;
 }
 
-const clientOptions = ({ url, extensions, middleware, poolOptions, verifyMarker }: DatabaseLayerOptions) => ({
-	url: typeof url === "string" ? url : Redacted.value(url),
-	...(extensions === undefined ? {} : { extensions }),
-	...(middleware === undefined ? {} : { middleware }),
-	...(poolOptions === undefined ? {} : { poolOptions }),
-	...(verifyMarker === undefined ? {} : { verifyMarker }),
-});
+function clientOptions({ url, extensions, middleware, poolOptions, verifyMarker }: DatabaseLayerOptions) {
+	return {
+		url: typeof url === "string" ? url : Redacted.value(url),
+		...(extensions === undefined ? {} : { extensions }),
+		...(middleware === undefined ? {} : { middleware }),
+		...(poolOptions === undefined ? {} : { poolOptions }),
+		...(verifyMarker === undefined ? {} : { verifyMarker }),
+	};
+}
 
-const defaultModels = <Contract extends AnySqlContract, Models extends object>(client: Pick<PostgresClient<Contract>, "contract" | "orm">): Models =>
-	namespaceModels<Contract, Models>(client.contract, client.orm);
+function defaultModels<TContract extends AnySqlContract, TModels extends object>(
+	client: Pick<PostgresClient<TContract>, "contract" | "orm">,
+): TModels {
+	return namespaceModels<TContract, TModels>(client.contract, client.orm);
+}
 
 export const makeDatabase =
-	<const Contract extends AnySqlContract>() =>
-	<const Identifier extends string>(
-		identifier: DatabaseIdentifierLiteral<Identifier>,
-		options: DatabaseFactoryOptions<Contract>,
-	): DatabaseDefinition<Contract, Identifier> => {
-		type Models = DefaultModels<Contract>;
+	<const TContract extends AnySqlContract>() =>
+	<const TIdentifier extends string>(
+		identifier: DatabaseIdentifierLiteral<TIdentifier>,
+		options: DatabaseFactoryOptions<TContract>,
+	): DatabaseDefinition<TContract, TIdentifier> => {
+		type Models = DefaultModels<TContract>;
 
-		return makeSqlDatabase<Contract, Identifier, DatabaseLayerOptions>(identifier, (layerOptions) => {
+		return makeSqlDatabase<TContract, TIdentifier, DatabaseLayerOptions>(identifier, (layerOptions) => {
 			const forwarded = clientOptions(layerOptions);
 			const client =
 				options.contract === undefined
-					? postgres<Contract>({
+					? postgres<TContract>({
 							...forwarded,
 							contractJson: options.contractJson,
 						})
-					: postgres<Contract>({
+					: postgres<TContract>({
 							...forwarded,
 							contract: options.contract,
 						});
@@ -67,7 +73,7 @@ export const makeDatabase =
 						open: true,
 					},
 					mode: "root",
-					models: defaultModels<Contract, Models>(client),
+					models: defaultModels<TContract, Models>(client),
 					querySemaphore: undefined,
 					transactionIdentity: undefined,
 					transactionSemaphore: undefined,

package/src/databaseTypes.ts

@@ -4,62 +4,62 @@ import type { PrismaError } from "#error.ts";
 import type { AnySqlContract } from "#internal/executor.ts";
 import type { Relation } from "#relation.ts";
 
-type OrmFor<Contract extends AnySqlContract> = ReturnType<typeof orm<Contract>>;
-type DefaultNamespaceId<Contract extends AnySqlContract> = "__unbound__" extends keyof OrmFor<Contract>
+type OrmFor<TContract extends AnySqlContract> = ReturnType<typeof orm<TContract>>;
+type DefaultNamespaceId<TContract extends AnySqlContract> = "__unbound__" extends keyof OrmFor<TContract>
 	? "__unbound__"
-	: "public" extends keyof OrmFor<Contract>
+	: "public" extends keyof OrmFor<TContract>
 		? "public"
-		: keyof OrmFor<Contract>;
-export type DefaultModels<Contract extends AnySqlContract> = OrmFor<Contract>[DefaultNamespaceId<Contract>] extends infer Models extends object
-	? Models
+		: keyof OrmFor<TContract>;
+export type DefaultModels<TContract extends AnySqlContract> = OrmFor<TContract>[DefaultNamespaceId<TContract>] extends infer TModels extends object
+	? TModels
 	: never;
 
-type IsUnion<Value, Whole = Value> = Value extends unknown ? ([Whole] extends [Value] ? false : true) : never;
+type IsUnion<TValue, TWhole = TValue> = TValue extends unknown ? ([TWhole] extends [TValue] ? false : true) : never;
 
-type IsSingletonString<Value extends string> = Record<never, never> extends Record<Value, never> ? false : true;
+type IsSingletonString<TValue extends string> = Record<never, never> extends Record<TValue, never> ? false : true;
 
 export const internalContextIdentifierPrefix = "\0@shivaedev/effect-prisma/internal/";
 
-export type DatabaseIdentifierLiteral<Identifier extends string> = [Identifier] extends [`\0@shivaedev/effect-prisma/internal/${string}`]
+export type DatabaseIdentifierLiteral<TIdentifier extends string> = [TIdentifier] extends [`\0@shivaedev/effect-prisma/internal/${string}`]
 	? never
-	: string extends Identifier
+	: string extends TIdentifier
 		? never
-		: true extends IsUnion<Identifier>
+		: true extends IsUnion<TIdentifier>
 			? never
-			: IsSingletonString<Identifier> extends true
-				? Identifier
+			: IsSingletonString<TIdentifier> extends true
+				? TIdentifier
 				: never;
 
-export interface DatabaseIdentifier<Contract extends AnySqlContract, Identifier extends string> {
-	readonly _contract: (contract: Contract) => Contract;
-	readonly _databaseIdentifier: (identifier: Identifier) => Identifier;
+export interface DatabaseIdentifier<TContract extends AnySqlContract, TIdentifier extends string> {
+	readonly _contract: (contract: TContract) => TContract;
+	readonly _databaseIdentifier: (identifier: TIdentifier) => TIdentifier;
 }
 
-type DatabaseModels<Contract extends AnySqlContract, Identifier extends string> = {
-	readonly [Model in keyof DefaultModels<Contract>]: Relation<
-		DefaultModels<Contract>[Model],
-		Contract,
-		Model & string,
-		DatabaseIdentifier<Contract, Identifier>
+type DatabaseModels<TContract extends AnySqlContract, TIdentifier extends string> = {
+	readonly [TModel in keyof DefaultModels<TContract>]: Relation<
+		DefaultModels<TContract>[TModel],
+		TContract,
+		TModel & string,
+		DatabaseIdentifier<TContract, TIdentifier>
 	>;
 };
 
-export type DatabaseService<Contract extends AnySqlContract, Identifier extends string> = DatabaseModels<Contract, Identifier> & {
+export type DatabaseService<TContract extends AnySqlContract, TIdentifier extends string> = DatabaseModels<TContract, TIdentifier> & {
 	transaction: <A, E, R>(
-		program: Effect.Effect<A, E, R> & (DatabaseIdentifier<Contract, Identifier> extends R ? unknown : never),
-	) => Effect.Effect<A, E | PrismaError, Exclude<R, DatabaseIdentifier<Contract, Identifier>>>;
+		program: Effect.Effect<A, E, R> & (DatabaseIdentifier<TContract, TIdentifier> extends R ? unknown : never),
+	) => Effect.Effect<A, E | PrismaError, Exclude<R, DatabaseIdentifier<TContract, TIdentifier>>>;
 };
 
-export interface DatabaseServiceHolder<Contract extends AnySqlContract, Identifier extends string>
-	extends Context.Service<DatabaseIdentifier<Contract, Identifier>, DatabaseService<Contract, Identifier>> {}
+export interface DatabaseServiceHolder<TContract extends AnySqlContract, TIdentifier extends string>
+	extends Context.Service<DatabaseIdentifier<TContract, TIdentifier>, DatabaseService<TContract, TIdentifier>> {}
 
 export type AnyDatabase = Effect.Effect<unknown, never, unknown> & {
 	readonly layer: (...arguments_: readonly never[]) => Layer.Any;
 };
 
-export type DatabaseServiceOf<Database extends AnyDatabase> = Effect.Success<Database>;
+export type DatabaseServiceOf<TDatabase extends AnyDatabase> = Effect.Success<TDatabase>;
 
-export interface SqlDatabase<Contract extends AnySqlContract, Identifier extends string, Options>
-	extends DatabaseServiceHolder<Contract, Identifier> {
-	readonly layer: (options: Options) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
+export interface SqlDatabase<TContract extends AnySqlContract, TIdentifier extends string, TOptions>
+	extends DatabaseServiceHolder<TContract, TIdentifier> {
+	readonly layer: (options: TOptions) => Layer.Layer<DatabaseIdentifier<TContract, TIdentifier>, PrismaError>;
 }

package/src/internal/adapters/transaction-settlement.ts

@@ -8,8 +8,9 @@ interface Settled {
 	readonly transaction: SettledTransaction;
 }
 
-const runtimeFailure = (code: string, cause: unknown, details?: Readonly<Record<string, unknown>>): Error & { readonly code: string } =>
-	Object.assign(new Error(code, { cause }), { code, ...details });
+function runtimeFailure(code: string, cause: unknown, details?: Readonly<Record<string, unknown>>): Error & { readonly code: string } {
+	return Object.assign(new Error(code, { cause }), { code, ...details });
+}
 
 class ConnectionDisposal {
 	disposed = false;
@@ -28,7 +29,7 @@ class ConnectionDisposal {
 	}
 }
 
-const commit = async ({ transaction }: Settled, disposal: ConnectionDisposal): Promise<unknown> => {
+async function commit({ transaction }: Settled, disposal: ConnectionDisposal): Promise<unknown> {
 	try {
 		await transaction.commit();
 		return undefined;
@@ -36,9 +37,9 @@ const commit = async ({ transaction }: Settled, disposal: ConnectionDisposal): P
 		await transaction.rollback().catch(() => disposal.destroy(commitError));
 		return runtimeFailure("RUNTIME.TRANSACTION_COMMIT_FAILED", commitError);
 	}
-};
+}
 
-const rollback = async ({ transaction }: Settled, disposal: ConnectionDisposal): Promise<unknown> => {
+async function rollback({ transaction }: Settled, disposal: ConnectionDisposal): Promise<unknown> {
 	try {
 		await transaction.rollback();
 		return undefined;
@@ -46,9 +47,9 @@ const rollback = async ({ transaction }: Settled, disposal: ConnectionDisposal):
 		await disposal.destroy(rollbackError);
 		return runtimeFailure("RUNTIME.TRANSACTION_ROLLBACK_FAILED", rollbackError);
 	}
-};
+}
 
-const release = async ({ connection }: Settled, disposal: ConnectionDisposal, failure: unknown): Promise<void> => {
+async function release({ connection }: Settled, disposal: ConnectionDisposal, failure: unknown): Promise<void> {
 	if (disposal.disposed) {
 		return;
 	}
@@ -58,7 +59,7 @@ const release = async ({ connection }: Settled, disposal: ConnectionDisposal, fa
 		await disposal.destroy(releaseError);
 		throw failure === undefined ? releaseError : runtimeFailure("RUNTIME.TRANSACTION_RELEASE_FAILED", failure, { releaseError });
 	}
-};
+}
 
 export const settleConnection = async (settled: Settled, commitTransaction: boolean): Promise<void> => {
 	const disposal = new ConnectionDisposal(settled.connection);

package/src/internal/database-facade.ts

@@ -6,33 +6,33 @@ import type { AnySqlContract, DatabaseExecutor } from "./executor.ts";
 import { makeModelRelation } from "./relation-runtime.ts";
 import { acquireTransaction, releaseTransaction, type TransactionOrm, withTransactionSemaphore } from "./transaction.ts";
 
-export interface ActiveTransaction<Contract extends AnySqlContract, Identifier extends string> {
-	readonly executor: DatabaseExecutor<DefaultModels<Contract>, Contract>;
-	readonly facade: DatabaseService<Contract, Identifier>;
+export interface ActiveTransaction<TContract extends AnySqlContract, TIdentifier extends string> {
+	readonly executor: DatabaseExecutor<DefaultModels<TContract>, TContract>;
+	readonly facade: DatabaseService<TContract, TIdentifier>;
 }
 
-export interface FacadeScope<Contract extends AnySqlContract, Identifier extends string> {
-	readonly activeTransaction: Context.Reference<ActiveTransaction<Contract, Identifier> | undefined>;
-	readonly executors: WeakMap<DatabaseService<Contract, Identifier>, DatabaseExecutor<DefaultModels<Contract>, Contract>>;
-	readonly service: Context.Service<DatabaseIdentifier<Contract, Identifier>, DatabaseService<Contract, Identifier>>;
+export interface FacadeScope<TContract extends AnySqlContract, TIdentifier extends string> {
+	readonly activeTransaction: Context.Reference<ActiveTransaction<TContract, TIdentifier> | undefined>;
+	readonly executors: WeakMap<DatabaseService<TContract, TIdentifier>, DatabaseExecutor<DefaultModels<TContract>, TContract>>;
+	readonly service: Context.Service<DatabaseIdentifier<TContract, TIdentifier>, DatabaseService<TContract, TIdentifier>>;
 }
 
 // Prisma Next builds each namespace's model clients from the contract, so they are the contract's DefaultModels.
-export function contractModels<Models extends object>(namespace: unknown): Models;
+export function contractModels<TModels extends object>(namespace: unknown): TModels;
 export function contractModels(namespace: unknown): unknown {
 	return namespace;
 }
 
 // The facade serves `transaction` itself and a Relation for every other model name, matching DatabaseService.
-function databaseFacade<Contract extends AnySqlContract, Identifier extends string>(facade: object): DatabaseService<Contract, Identifier>;
+function databaseFacade<TContract extends AnySqlContract, TIdentifier extends string>(facade: object): DatabaseService<TContract, TIdentifier>;
 function databaseFacade(facade: object): unknown {
 	return facade;
 }
 
-export const namespaceModels = <Contract extends AnySqlContract, Models extends object>(
-	contract: Contract,
-	namespacedOrm: TransactionOrm<Contract>,
-): Models => {
+export const namespaceModels = <TContract extends AnySqlContract, TModels extends object>(
+	contract: TContract,
+	namespacedOrm: TransactionOrm<TContract>,
+): TModels => {
 	const namespaces = Object.entries(contract.domain.namespaces);
 	const [only] = namespaces;
 	if (namespaces.length !== 1 || only === undefined) {
@@ -40,18 +40,18 @@ export const namespaceModels = <Contract extends AnySqlContract, Models extends
 	}
 	const [postgresSchemaOrSqliteUnbound, namespace] = only;
 	assertAvailableModelNames(Object.keys(namespace.models));
-	return contractModels<Models>(Reflect.get(namespacedOrm, postgresSchemaOrSqliteUnbound));
+	return contractModels<TModels>(Reflect.get(namespacedOrm, postgresSchemaOrSqliteUnbound));
 };
 
-export const runTransaction = <Contract extends AnySqlContract, Identifier extends string, A, E, R>(
-	scope: FacadeScope<Contract, Identifier>,
-	current: DatabaseExecutor<DefaultModels<Contract>, Contract>,
-	currentFacade: DatabaseService<Contract, Identifier>,
+export const runTransaction = <TContract extends AnySqlContract, TIdentifier extends string, A, E, R>(
+	scope: FacadeScope<TContract, TIdentifier>,
+	current: DatabaseExecutor<DefaultModels<TContract>, TContract>,
+	currentFacade: DatabaseService<TContract, TIdentifier>,
 	program: Effect.Effect<A, E, R>,
 	release: typeof releaseTransaction,
 	mode: "test" | "transaction",
 	span: string,
-): Effect.Effect<A, E | PrismaError, Exclude<R, DatabaseIdentifier<Contract, Identifier>>> => {
+): Effect.Effect<A, E | PrismaError, Exclude<R, DatabaseIdentifier<TContract, TIdentifier>>> => {
 	if (!current.liveness.open) {
 		return Effect.fail(toPrismaError({ code: current.liveness.closedCode }));
 	}
@@ -69,7 +69,7 @@ export const runTransaction = <Contract extends AnySqlContract, Identifier exten
 	const transaction = Effect.acquireUseRelease(
 		acquireTransaction(
 			current,
-			(transactionOrm) => namespaceModels<Contract, DefaultModels<Contract>>(current.client.contract, transactionOrm),
+			(transactionOrm) => namespaceModels<TContract, DefaultModels<TContract>>(current.client.contract, transactionOrm),
 			mode,
 		),
 		(resource) => {
@@ -88,11 +88,11 @@ export const runTransaction = <Contract extends AnySqlContract, Identifier exten
 	return withTransactionSemaphore(current.transactionSemaphore, transaction);
 };
 
-export function makeFacade<Contract extends AnySqlContract, Identifier extends string>(
-	scope: FacadeScope<Contract, Identifier>,
-	current: DatabaseExecutor<DefaultModels<Contract>, Contract>,
-): DatabaseService<Contract, Identifier> {
-	let facade: DatabaseService<Contract, Identifier>;
+export function makeFacade<TContract extends AnySqlContract, TIdentifier extends string>(
+	scope: FacadeScope<TContract, TIdentifier>,
+	current: DatabaseExecutor<DefaultModels<TContract>, TContract>,
+): DatabaseService<TContract, TIdentifier> {
+	let facade: DatabaseService<TContract, TIdentifier>;
 	const resolveActiveTransaction = Effect.flatMap(scope.activeTransaction, (active) => {
 		if (current.mode === "root") {
 			return Effect.succeed(active ?? { executor: current, facade });
@@ -110,7 +110,7 @@ export function makeFacade<Contract extends AnySqlContract, Identifier extends s
 	);
 	const target: object = Object.create(null);
 	Object.assign(target, {
-		transaction: <A, E, R>(program: Effect.Effect<A, E, R> & (DatabaseIdentifier<Contract, Identifier> extends R ? unknown : never)) =>
+		transaction: <A, E, R>(program: Effect.Effect<A, E, R> & (DatabaseIdentifier<TContract, TIdentifier> extends R ? unknown : never)) =>
 			Effect.suspend(() => {
 				if (!current.liveness.open) {
 					return Effect.fail(toPrismaError({ code: current.liveness.closedCode }));
@@ -120,7 +120,7 @@ export function makeFacade<Contract extends AnySqlContract, Identifier extends s
 				);
 			}),
 	});
-	facade = databaseFacade<Contract, Identifier>(
+	facade = databaseFacade<TContract, TIdentifier>(
 		new Proxy(target, {
 			get(target, property, receiver) {
 				if (Reflect.has(target, property)) {

package/src/internal/database-factory.ts

@@ -15,31 +15,31 @@ import { releaseTestTransaction } from "./transaction.ts";
 
 let activeTransactionReferenceSequence = 0;
 
-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, Identifier, Options> => {
+export const makeSqlDatabase = <const TContract extends AnySqlContract, const TIdentifier extends string, TOptions>(
+	identifier: DatabaseIdentifierLiteral<TIdentifier>,
+	acquireExecutor: (options: TOptions) => Effect.Effect<DatabaseExecutor<DefaultModels<TContract>, TContract>, PrismaError>,
+): SqlDatabase<TContract, TIdentifier, TOptions> => {
 	if (identifier.startsWith(internalContextIdentifierPrefix)) {
 		throw new TypeError("Database identifier uses a reserved internal namespace");
 	}
-	type Models = DefaultModels<Contract>;
-	type DatabaseId = DatabaseIdentifier<Contract, Identifier>;
+	type Models = DefaultModels<TContract>;
+	type DatabaseId = DatabaseIdentifier<TContract, TIdentifier>;
 
-	const Service = Context.Service<DatabaseId, DatabaseService<Contract, Identifier>>(identifier);
-	const scope: FacadeScope<Contract, Identifier> = {
-		activeTransaction: Context.Reference<ActiveTransaction<Contract, Identifier> | undefined>(
+	const Service = Context.Service<DatabaseId, DatabaseService<TContract, TIdentifier>>(identifier);
+	const scope: FacadeScope<TContract, TIdentifier> = {
+		activeTransaction: Context.Reference<ActiveTransaction<TContract, TIdentifier> | undefined>(
 			`${internalContextIdentifierPrefix}ActiveTransaction/${activeTransactionReferenceSequence++}`,
 			{ defaultValue: () => undefined },
 		),
 		executors: new WeakMap(),
 		service: Service,
 	};
-	const executorOf = (facade: DatabaseService<Contract, Identifier>): Effect.Effect<DatabaseExecutor<Models, Contract>> => {
+	function executorOf(facade: DatabaseService<TContract, TIdentifier>): Effect.Effect<DatabaseExecutor<Models, TContract>> {
 		const executor = scope.executors.get(facade);
 		return executor === undefined
 			? Effect.die(new TypeError("The database service was not created by its database Layer"))
 			: Effect.succeed(executor);
-	};
+	}
 
 	const withTestTransaction = <A, E, R>(
 		program: Effect.Effect<A, E, R> & (DatabaseId extends R ? unknown : never),
@@ -50,7 +50,7 @@ export const makeSqlDatabase = <const Contract extends AnySqlContract, const Ide
 			),
 		);
 
-	const layer = (layerOptions: Options): Layer.Layer<DatabaseId, PrismaError> => {
+	const layer = (layerOptions: TOptions): Layer.Layer<DatabaseId, PrismaError> => {
 		const acquire = Effect.acquireRelease(
 			Effect.suspend(() => acquireExecutor(layerOptions)),
 			(executor) => {

package/src/internal/dynamic.ts

@@ -1,4 +1,6 @@
-const isObjectLike = (value: unknown): value is object => (typeof value === "object" && value !== null) || typeof value === "function";
+function isObjectLike(value: unknown): value is object {
+	return (typeof value === "object" && value !== null) || typeof value === "function";
+}
 
 export const hasMethod = (value: unknown, name: PropertyKey): value is object =>
 	isObjectLike(value) && typeof Reflect.get(value, name) === "function";

package/src/internal/executor.ts

@@ -6,22 +6,22 @@ import type { Semaphore } from "effect";
 export type AnySqlContract = PrismaContract<SqlStorage>;
 export type AnyPostgresContract = AnySqlContract;
 
-export interface SqlDatabaseClient<Contract extends AnySqlContract> {
+export interface SqlDatabaseClient<TContract extends AnySqlContract> {
 	close: () => Promise<void>;
-	readonly context: ExecutionContext<Contract>;
-	readonly contract: Contract;
+	readonly context: ExecutionContext<TContract>;
+	readonly contract: TContract;
 	runtime: () => Runtime;
 }
 
-export interface DatabaseExecutor<Models extends object, Contract extends AnySqlContract = AnySqlContract> {
-	readonly client: SqlDatabaseClient<Contract>;
+export interface DatabaseExecutor<TModels extends object, TContract extends AnySqlContract = AnySqlContract> {
+	readonly client: SqlDatabaseClient<TContract>;
 	readonly identity: object;
 	readonly liveness: {
 		readonly closedCode: string;
 		open: boolean;
 	};
 	readonly mode: "root" | "test" | "transaction";
-	readonly models: Models;
+	readonly models: TModels;
 	readonly querySemaphore: Semaphore.Semaphore | undefined;
 	readonly transactionIdentity: object | undefined;
 	readonly transactionSemaphore: Semaphore.Semaphore | undefined;

package/src/internal/recipe.ts

@@ -23,7 +23,7 @@ export const appendOperation = (parent: RelationRecipe, name: PropertyKey, argum
 	parent,
 });
 
-const operations = (recipe: RelationRecipe): readonly RelationOperation[] => {
+function operations(recipe: RelationRecipe): readonly RelationOperation[] {
 	const reversed: RelationOperation[] = [];
 	let current: RelationRecipe | undefined = recipe;
 
@@ -35,16 +35,16 @@ const operations = (recipe: RelationRecipe): readonly RelationOperation[] => {
 	}
 
 	return reversed.reverse();
-};
+}
 
-const applyMethod = (current: unknown, name: PropertyKey, arguments_: readonly unknown[], model: string): unknown => {
+function applyMethod(current: unknown, name: PropertyKey, arguments_: readonly unknown[], model: string): unknown {
 	if (!hasMethod(current, name)) {
 		throw new TypeError(`Cannot call ${String(name)} while replaying ${model}`);
 	}
 	return invokeMethod(current, name, arguments_);
-};
+}
 
-const replayPlan = (collection: unknown, plan: RelationPlan, owner: object, transactionIdentity: object | undefined): unknown => {
+function replayPlan(collection: unknown, plan: RelationPlan, owner: object, transactionIdentity: object | undefined): unknown {
 	if (!plan.liveness.open) {
 		throw new TypeError("Included Relation is closed");
 	}
@@ -64,9 +64,9 @@ const replayPlan = (collection: unknown, plan: RelationPlan, owner: object, tran
 		return refined;
 	}
 	return applyMethod(refined, "count", [], plan.recipe.model);
-};
+}
 
-const includeRefinement = (value: unknown, owner: object, transactionIdentity: object | undefined): ((collection: unknown) => unknown) => {
+function includeRefinement(value: unknown, owner: object, transactionIdentity: object | undefined): (collection: unknown) => unknown {
 	const plan = getRelationPlan(value);
 	if (plan !== undefined) {
 		return (collection) => replayPlan(collection, plan, owner, transactionIdentity);
@@ -97,9 +97,9 @@ const includeRefinement = (value: unknown, owner: object, transactionIdentity: o
 		const branches = Object.fromEntries(plans.map(([name, queryPlan]) => [name, replayPlan(collection, queryPlan, owner, transactionIdentity)]));
 		return applyMethod(collection, "combine", [branches], model ?? "relation");
 	};
-};
+}
 
-const replayRecipeFrom = (root: unknown, recipe: RelationRecipe, owner: object, transactionIdentity: object | undefined): unknown => {
+function replayRecipeFrom(root: unknown, recipe: RelationRecipe, owner: object, transactionIdentity: object | undefined): unknown {
 	let current = root;
 	for (const operation of operations(recipe)) {
 		const arguments_ =
@@ -109,7 +109,7 @@ const replayRecipeFrom = (root: unknown, recipe: RelationRecipe, owner: object,
 		current = applyMethod(current, operation.name, arguments_, recipe.model);
 	}
 	return current;
-};
+}
 
 export const replayRecipe = (models: object, recipe: RelationRecipe, owner: object, transactionIdentity: object | undefined): unknown => {
 	const current: unknown = Reflect.get(models, recipe.model);

package/src/internal/relation-result.ts

@@ -3,10 +3,13 @@ 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));
+function settle(value: unknown, map: (result: unknown) => unknown): Effect.Effect<unknown, PrismaError> {
+	return 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);
+function countOf(result: unknown): unknown {
+	return 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")) {

package/src/internal/relation-runtime.ts

@@ -1,6 +1,7 @@
 import { Effect, Effectable, type Stream } from "effect";
 import type { PrismaError } from "#error.ts";
 import type { Relation } from "#relation.ts";
+import { hasMethod } from "./dynamic.ts";
 import type { AnyPostgresContract, DatabaseExecutor } from "./executor.ts";
 import { executeQuery } from "./query-execution.ts";
 import { appendOperation, type RelationRecipe, replayRecipe, rootRecipe } from "./recipe.ts";
@@ -8,10 +9,10 @@ import { setRelationPlan } from "./relation-plan.ts";
 import { evaluateResult } from "./relation-result.ts";
 import { makeRelationStream } from "./relation-stream.ts";
 
-interface RelationRuntime<Models extends object, Contract extends AnyPostgresContract> {
-	readonly executor: DatabaseExecutor<Models, Contract>;
+interface RelationRuntime<TModels extends object, TContract extends AnyPostgresContract> {
+	readonly executor: DatabaseExecutor<TModels, TContract>;
 	readonly recipe: RelationRecipe;
-	readonly resolveExecutor: Effect.Effect<DatabaseExecutor<Models, Contract>, PrismaError>;
+	readonly resolveExecutor: Effect.Effect<DatabaseExecutor<TModels, TContract>, PrismaError>;
 	readonly terminal?: PropertyKey;
 }
 
@@ -23,15 +24,15 @@ type AnyRelationRuntime = RelationRuntime<object, AnyPostgresContract>;
 
 const runtimes = new WeakMap<object, AnyRelationRuntime>();
 
-const runtimeOf = (self: object): AnyRelationRuntime => {
+function runtimeOf(self: object): AnyRelationRuntime {
 	const runtime = runtimes.get(self);
 	if (runtime === undefined) {
 		throw new TypeError("Relation runtime is unavailable");
 	}
 	return runtime;
-};
+}
 
-const relationEffect = (self: object): Effect.Effect<unknown, PrismaError> => {
+function relationEffect(self: object): Effect.Effect<unknown, PrismaError> {
 	const runtime = runtimeOf(self);
 	return Effect.flatMap(runtime.resolveExecutor, (executor) =>
 		executeQuery(
@@ -50,11 +51,11 @@ const relationEffect = (self: object): Effect.Effect<unknown, PrismaError> => {
 			kind: "client",
 		}),
 	);
-};
+}
 
 const RelationPrototype = {
 	...Effectable.Prototype<RelationValue>({
-		evaluate() {
+		evaluate(this: RelationValue) {
 			return relationEffect(this);
 		},
 		label: "EffectPrismaRelation",
@@ -65,7 +66,7 @@ const RelationPrototype = {
 	},
 };
 
-const makeRelationProxy = (runtime: AnyRelationRuntime): object => {
+function makeRelationProxy(runtime: AnyRelationRuntime): object {
 	const target: object = Object.create(RelationPrototype);
 	const proxy = new Proxy(target, {
 		get(self, property, receiver) {
@@ -89,6 +90,10 @@ const makeRelationProxy = (runtime: AnyRelationRuntime): object => {
 						terminal: "count",
 					});
 			}
+			// Effect reads protocol keys such as its Exit identifier from every yielded value, so only the collection's own methods become Relation calls.
+			if (!hasMethod(Reflect.get(runtime.executor.models, runtime.recipe.model), property)) {
+				return undefined;
+			}
 			return (...arguments_: readonly unknown[]) =>
 				makeRelationProxy({
 					...runtime,
@@ -109,25 +114,25 @@ const makeRelationProxy = (runtime: AnyRelationRuntime): object => {
 		setRelationPlan(value, plan);
 	}
 	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<TCollection, TModel extends string>(proxy: object): Relation<TCollection, undefined, TModel>;
 function asRelation(proxy: object): unknown {
 	return proxy;
 }
 
 export const makeModelRelation = <
-	Collection,
-	Models extends object,
-	ExecutorContract extends AnyPostgresContract = AnyPostgresContract,
-	Model extends string = string,
+	TCollection,
+	TModels extends object,
+	TExecutorContract extends AnyPostgresContract = AnyPostgresContract,
+	TModel extends string = string,
 >(
-	executor: DatabaseExecutor<Models, ExecutorContract>,
-	model: Model,
-	resolveExecutor: Effect.Effect<DatabaseExecutor<Models, ExecutorContract>, PrismaError> = Effect.succeed(executor),
-): Relation<Collection, undefined, Model> =>
-	asRelation<Collection, Model>(
+	executor: DatabaseExecutor<TModels, TExecutorContract>,
+	model: TModel,
+	resolveExecutor: Effect.Effect<DatabaseExecutor<TModels, TExecutorContract>, PrismaError> = Effect.succeed(executor),
+): Relation<TCollection, undefined, TModel> =>
+	asRelation<TCollection, TModel>(
 		makeRelationProxy({
 			executor,
 			recipe: rootRecipe(model),