@shivaedev/effect-prisma 0.6.2 → 0.6.4

package/src/internal/database-factory.ts

@@ -1,328 +1,60 @@
-import type { orm } from "@prisma-next/sql-orm-client";
 import { Context, Effect, Layer } from "effect";
-import { type PrismaError, toPrismaError } from "../error.js";
-import type { Relation } from "../relation.js";
-import { assertAvailableModelNames } from "./client-lifecycle.js";
-import type { AnySqlContract, DatabaseExecutor } from "./executor.js";
-import { makeModelRelation } from "./relation-runtime.js";
-import { DatabaseTestingTypeId } from "./testing.js";
+import type { PrismaError } from "../error.ts";
+import { type ActiveTransaction, type FacadeScope, makeFacade, runTransaction } from "./database-facade.ts";
 import {
-	acquireTransaction,
-	releaseTestTransaction,
-	releaseTransaction,
-	type TransactionOrm,
-	withTransactionSemaphore,
-} from "./transaction.js";
+	type DatabaseIdentifier,
+	type DatabaseIdentifierLiteral,
+	type DatabaseService,
+	type DefaultModels,
+	internalContextIdentifierPrefix,
+	type SqlDatabase,
+} from "./database-types.ts";
+import type { AnySqlContract, DatabaseExecutor } from "./executor.ts";
+import { DatabaseTestingTypeId } from "./testing.ts";
+import { releaseTestTransaction } from "./transaction.ts";
 
-type OrmFor<Contract extends AnySqlContract> = ReturnType<typeof orm<Contract>>;
-type DefaultNamespaceId<Contract extends AnySqlContract> =
-	"__unbound__" extends keyof OrmFor<Contract>
-		? "__unbound__"
-		: "public" extends keyof OrmFor<Contract>
-			? "public"
-			: keyof OrmFor<Contract>;
-export type DefaultModels<Contract extends AnySqlContract> =
-	OrmFor<Contract>[DefaultNamespaceId<Contract>] extends infer Models extends
-		object
-		? Models
-		: never;
-
-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,
-	Identifier extends string,
-> = {
-	readonly [Model in keyof DefaultModels<Contract>]: Relation<
-		DefaultModels<Contract>[Model],
-		Contract,
-		Model & string,
-		DatabaseIdentifier<Contract, Identifier>
-	>;
-};
-
-export type DatabaseService<
-	Contract extends AnySqlContract,
-	Identifier extends string,
-> = DatabaseModels<Contract, Identifier> & {
-	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>>
-	>;
-};
-
-/**
- * The driver-independent part of a database definition: the Context service
- * carrying the typed facade. Driver entrypoints add their own `layer` options.
- */
-export interface DatabaseServiceHolder<
-	Contract extends AnySqlContract,
-	Identifier extends string,
-> extends Context.Service<
-		DatabaseIdentifier<Contract, Identifier>,
-		DatabaseService<Contract, Identifier>
-	> {}
-
-export type AnyDatabase = Effect.Effect<unknown, never, unknown> & {
-	readonly layer: (...arguments_: ReadonlyArray<never>) => Layer.Any;
-};
-
-export type DatabaseServiceOf<Database extends AnyDatabase> =
-	Effect.Success<Database>;
-
-export interface SqlDatabase<
-	Contract extends AnySqlContract,
-	Identifier extends string,
-	Options,
-> extends DatabaseServiceHolder<Contract, Identifier> {
-	readonly layer: (
-		options: Options,
-	) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
-}
-
-/**
- * Resolve the models of the single domain namespace from a namespaced ORM
- * client. Prisma Next namespaces PostgreSQL models under their schema and
- * SQLite models under the unbound namespace.
- */
-export const namespaceModels = <
-	Contract extends AnySqlContract,
-	Models extends object,
->(
-	contract: Contract,
-	namespacedOrm: TransactionOrm<Contract>,
-): Models => {
-	const namespaces = Object.keys(contract.domain.namespaces);
-	if (namespaces.length !== 1 || namespaces[0] === undefined) {
-		throw new TypeError(
-			"Effect Prisma currently requires exactly one domain namespace",
-		);
-	}
-	assertAvailableModelNames(
-		Object.keys(contract.domain.namespaces[namespaces[0]].models),
-	);
-	return Reflect.get(namespacedOrm, namespaces[0]) as Models;
-};
-
 /**
  * Assemble the database service and its Layer around a driver-specific
  * executor acquisition.
  */
-export const makeSqlDatabase = <
-	const Contract extends AnySqlContract,
-	const Identifier extends string,
-	Options,
->(
+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
-	>,
+	acquireExecutor: (options: Options) => Effect.Effect<DatabaseExecutor<DefaultModels<Contract>, Contract>, PrismaError>,
 ): SqlDatabase<Contract, Identifier, Options> => {
 	if (identifier.startsWith(internalContextIdentifierPrefix)) {
-		throw new TypeError(
-			"Database identifier uses a reserved internal namespace",
-		);
+		throw new TypeError("Database identifier uses a reserved internal namespace");
 	}
 	type Models = DefaultModels<Contract>;
 	type DatabaseId = DatabaseIdentifier<Contract, Identifier>;
 
-	const Service = Context.Service<
-		DatabaseId,
-		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 Service = Context.Service<DatabaseId, DatabaseService<Contract, Identifier>>(identifier);
+	const scope: FacadeScope<Contract, Identifier> = {
+		activeTransaction: Context.Reference<ActiveTransaction<Contract, Identifier> | undefined>(
+			`${internalContextIdentifierPrefix}ActiveTransaction/${activeTransactionReferenceSequence++}`,
+			{ defaultValue: () => undefined },
+		),
+		executors: new WeakMap(),
+		service: Service,
 	};
-	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);
+	const executorOf = (facade: DatabaseService<Contract, Identifier>): Effect.Effect<DatabaseExecutor<Models, Contract>> => {
+		const executor = scope.executors.get(facade);
 		return executor === undefined
-			? Effect.die(
-					new TypeError(
-						"The database service was not created by its database Layer",
-					),
-				)
+			? 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 transaction = Effect.acquireUseRelease(
-			acquireTransaction(
-				current,
-				(transactionOrm) =>
-					namespaceModels<Contract, Models>(
-						current.client.contract,
-						transactionOrm,
-					),
-				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);
-	};
-
-	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);
-				}
-				if (typeof property !== "string") {
-					return undefined;
-				}
-				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",
-				),
+				runTransaction(scope, current, facade, program, releaseTestTransaction, "test", "prisma.testTransaction"),
 			);
 		});
 
-	const layer = (
-		layerOptions: Options,
-	): Layer.Layer<DatabaseId, PrismaError> => {
+	const layer = (layerOptions: Options): Layer.Layer<DatabaseId, PrismaError> => {
 		const acquire = Effect.acquireRelease(
 			Effect.suspend(() => acquireExecutor(layerOptions)),
 			(executor) => {
@@ -331,11 +63,11 @@ export const makeSqlDatabase = <
 			},
 		);
 
-		return Layer.effect(Service)(Effect.map(acquire, makeFacade));
+		return Layer.effect(Service)(Effect.map(acquire, (executor) => makeFacade(scope, executor)));
 	};
 
 	return Object.assign(Service, {
 		layer,
 		[DatabaseTestingTypeId]: { withTestTransaction },
-	}) as SqlDatabase<Contract, Identifier, Options>;
+	});
 };

package/src/internal/database-types.ts

@@ -0,0 +1,69 @@
+import type { orm } from "@prisma-next/sql-orm-client";
+import type { Context, Effect, Layer } from "effect";
+import type { PrismaError } from "../error.ts";
+import type { Relation } from "../relation.ts";
+import type { AnySqlContract } from "./executor.ts";
+
+type OrmFor<Contract extends AnySqlContract> = ReturnType<typeof orm<Contract>>;
+type DefaultNamespaceId<Contract extends AnySqlContract> = "__unbound__" extends keyof OrmFor<Contract>
+	? "__unbound__"
+	: "public" extends keyof OrmFor<Contract>
+		? "public"
+		: keyof OrmFor<Contract>;
+export type DefaultModels<Contract extends AnySqlContract> = OrmFor<Contract>[DefaultNamespaceId<Contract>] extends infer Models extends object
+	? Models
+	: never;
+
+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;
+
+export const internalContextIdentifierPrefix = "\0@shivaedev/effect-prisma/internal/";
+
+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, Identifier extends string> = {
+	readonly [Model in keyof DefaultModels<Contract>]: Relation<
+		DefaultModels<Contract>[Model],
+		Contract,
+		Model & string,
+		DatabaseIdentifier<Contract, Identifier>
+	>;
+};
+
+export type DatabaseService<Contract extends AnySqlContract, Identifier extends string> = DatabaseModels<Contract, Identifier> & {
+	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>>>;
+};
+
+/**
+ * The driver-independent part of a database definition: the Context service
+ * carrying the typed facade. Driver entrypoints add their own `layer` options.
+ */
+export interface DatabaseServiceHolder<Contract extends AnySqlContract, Identifier extends string>
+	extends Context.Service<DatabaseIdentifier<Contract, Identifier>, DatabaseService<Contract, Identifier>> {}
+
+export type AnyDatabase = Effect.Effect<unknown, never, unknown> & {
+	readonly layer: (...arguments_: ReadonlyArray<never>) => Layer.Any;
+};
+
+export type DatabaseServiceOf<Database extends AnyDatabase> = Effect.Success<Database>;
+
+export interface SqlDatabase<Contract extends AnySqlContract, Identifier extends string, Options>
+	extends DatabaseServiceHolder<Contract, Identifier> {
+	readonly layer: (options: Options) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
+}

package/src/internal/dynamic.ts

@@ -0,0 +1,16 @@
+const isObjectLike = (value: unknown): value is object => (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";
+
+export const invokeMethod = (target: object, name: PropertyKey, arguments_: ReadonlyArray<unknown>): unknown => {
+	const method: unknown = Reflect.get(target, name);
+	if (typeof method !== "function") {
+		throw new TypeError(`${String(name)} is not a method`);
+	}
+	return Reflect.apply(method, target, arguments_);
+};
+
+export const isPromiseLike = (value: unknown): value is PromiseLike<unknown> => hasMethod(value, "then");
+
+export const isAsyncIterable = (value: unknown): value is AsyncIterable<unknown> => hasMethod(value, Symbol.asyncIterator);

package/src/internal/executor.ts

@@ -17,10 +17,7 @@ export interface SqlDatabaseClient<Contract extends AnySqlContract> {
 	close(): Promise<void>;
 }
 
-export interface DatabaseExecutor<
-	Models extends object,
-	Contract extends AnySqlContract = AnySqlContract,
-> {
+export interface DatabaseExecutor<Models extends object, Contract extends AnySqlContract = AnySqlContract> {
 	readonly client: SqlDatabaseClient<Contract>;
 	readonly identity: object;
 	readonly liveness: {

package/src/internal/promise.ts

@@ -1,16 +1,8 @@
 import { Effect } from "effect";
-import { isPrismaFailure, type PrismaError, toPrismaError } from "../error.js";
+import { isPrismaFailure, type PrismaError, toPrismaError } from "../error.ts";
 
-export const fromPrismaPromise = <A>(
-	evaluate: (signal: AbortSignal) => PromiseLike<A>,
-): Effect.Effect<A, PrismaError> =>
+export const fromPrismaPromise = <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): Effect.Effect<A, PrismaError> =>
 	Effect.tryPromise({
 		try: (signal) => Promise.resolve(evaluate(signal)),
 		catch: (error) => error,
-	}).pipe(
-		Effect.catch((error) =>
-			isPrismaFailure(error)
-				? Effect.fail(toPrismaError(error))
-				: Effect.die(error),
-		),
-	);
+	}).pipe(Effect.catch((error) => (isPrismaFailure(error) ? Effect.fail(toPrismaError(error)) : Effect.die(error))));

package/src/internal/query-execution.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
-import { type PrismaError, toPrismaError } from "../error.js";
-import type { DatabaseExecutor } from "./executor.js";
+import { type PrismaError, toPrismaError } from "../error.ts";
+import type { DatabaseExecutor } from "./executor.ts";
 
 export const executeQuery = <A, E, R>(
 	executor: Pick<DatabaseExecutor<object>, "liveness" | "querySemaphore">,
@@ -8,11 +8,7 @@ export const executeQuery = <A, E, R>(
 ): 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 })),
+			executor.liveness.open ? effect : Effect.fail(toPrismaError({ code: executor.liveness.closedCode })),
 	);
-	return executor.querySemaphore === undefined
-		? checked
-		: executor.querySemaphore.withPermit(Effect.uninterruptible(checked));
+	return executor.querySemaphore === undefined ? checked : executor.querySemaphore.withPermit(Effect.uninterruptible(checked));
 };

package/src/internal/recipe.ts

@@ -1,4 +1,5 @@
-import { getRelationPlan, type RelationPlan } from "./relation-plan.js";
+import { hasMethod, invokeMethod } from "./dynamic.ts";
+import { getRelationPlan, type RelationPlan } from "./relation-plan.ts";
 
 export interface RelationOperation {
 	readonly name: PropertyKey;
@@ -13,11 +14,7 @@ export interface RelationRecipe {
 
 export const rootRecipe = (model: string): RelationRecipe => ({ model });
 
-export const appendOperation = (
-	parent: RelationRecipe,
-	name: PropertyKey,
-	arguments_: ReadonlyArray<unknown>,
-): RelationRecipe => ({
+export const appendOperation = (parent: RelationRecipe, name: PropertyKey, arguments_: ReadonlyArray<unknown>): RelationRecipe => ({
 	model: parent.model,
 	parent,
 	operation: {
@@ -26,9 +23,7 @@ export const appendOperation = (
 	},
 });
 
-const operations = (
-	recipe: RelationRecipe,
-): ReadonlyArray<RelationOperation> => {
+const operations = (recipe: RelationRecipe): ReadonlyArray<RelationOperation> => {
 	const reversed: Array<RelationOperation> = [];
 	let current: RelationRecipe | undefined = recipe;
 
@@ -42,81 +37,43 @@ const operations = (
 	return reversed.reverse();
 };
 
-const applyMethod = (
-	current: unknown,
-	name: PropertyKey,
-	arguments_: ReadonlyArray<unknown>,
-	model: string,
-): unknown => {
-	if (
-		typeof current !== "object" ||
-		current === null ||
-		typeof Reflect.get(current, name) !== "function"
-	) {
+const applyMethod = (current: unknown, name: PropertyKey, arguments_: ReadonlyArray<unknown>, model: string): unknown => {
+	if (!hasMethod(current, name)) {
 		throw new TypeError(`Cannot call ${String(name)} while replaying ${model}`);
 	}
-
-	const method = Reflect.get(current, name) as (
-		...arguments_: ReadonlyArray<unknown>
-	) => unknown;
-	return Reflect.apply(method, current, arguments_);
+	return invokeMethod(current, name, arguments_);
 };
 
-const replayPlan = (
-	collection: unknown,
-	plan: RelationPlan,
-	owner: object,
-	transactionIdentity: object | undefined,
-): 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
-	) {
+	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")
-			: undefined;
+	const relatedModel = typeof collection === "object" && collection !== null ? Reflect.get(collection, "modelName") : undefined;
 	if (typeof relatedModel === "string" && relatedModel !== plan.recipe.model) {
-		throw new TypeError(
-			`Included relation expects ${relatedModel}, received ${plan.recipe.model}`,
-		);
+		throw new TypeError(`Included relation expects ${relatedModel}, received ${plan.recipe.model}`);
 	}
 
-	const refined = replayRecipeFrom(
-		collection,
-		plan.recipe,
-		owner,
-		transactionIdentity,
-	);
+	const refined = replayRecipeFrom(collection, plan.recipe, owner, transactionIdentity);
 	if (plan.terminal !== "count") {
 		return refined;
 	}
 	return applyMethod(refined, "count", [], plan.recipe.model);
 };
 
-const includeRefinement = (
-	value: unknown,
-	owner: object,
-	transactionIdentity: object | undefined,
-): ((collection: unknown) => 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, owner, transactionIdentity);
+		return (collection) => replayPlan(collection, plan, owner, transactionIdentity);
 	}
 
 	if (typeof value !== "object" || value === null || Array.isArray(value)) {
-		throw new TypeError(
-			"An included relation must be a Relation or query record",
-		);
+		throw new TypeError("An included relation must be a Relation or query record");
 	}
 
 	const entries = Object.entries(value);
@@ -137,46 +94,24 @@ const includeRefinement = (
 	}
 
 	return (collection) => {
-		const branches = Object.fromEntries(
-			plans.map(([name, queryPlan]) => [
-				name,
-				replayPlan(collection, queryPlan, owner, transactionIdentity),
-			]),
-		);
+		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 => {
+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],
-							owner,
-							transactionIdentity,
-						),
-					]
+				? [operation.arguments[0], includeRefinement(operation.arguments[1], owner, transactionIdentity)]
 				: operation.arguments;
 		current = applyMethod(current, operation.name, arguments_, recipe.model);
 	}
 	return current;
 };
 
-export const replayRecipe = (
-	models: object,
-	recipe: RelationRecipe,
-	owner: object,
-	transactionIdentity: object | undefined,
-): unknown => {
+export const replayRecipe = (models: object, recipe: RelationRecipe, owner: object, transactionIdentity: object | undefined): unknown => {
 	const current: unknown = Reflect.get(models, recipe.model);
 
 	if (current === undefined) {