@shivaedev/effect-prisma 0.6.4 → 0.7.1

package/src/internal/database-factory.ts

@@ -1,5 +1,5 @@
 import { Context, Effect, Layer } from "effect";
-import type { PrismaError } from "../error.ts";
+import type { PrismaError } from "#error.ts";
 import { type ActiveTransaction, type FacadeScope, makeFacade, runTransaction } from "./database-facade.ts";
 import {
 	type DatabaseIdentifier,
@@ -15,10 +15,6 @@ import { releaseTestTransaction } from "./transaction.ts";
 
 let activeTransactionReferenceSequence = 0;
 
-/**
- * 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>(
 	identifier: DatabaseIdentifierLiteral<Identifier>,
 	acquireExecutor: (options: Options) => Effect.Effect<DatabaseExecutor<DefaultModels<Contract>, Contract>, PrismaError>,
@@ -48,11 +44,11 @@ export const makeSqlDatabase = <const Contract extends AnySqlContract, const Ide
 	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) =>
+		Effect.flatMap(Service, (facade) =>
+			Effect.flatMap(executorOf(facade), (current) =>
 				runTransaction(scope, current, facade, program, releaseTestTransaction, "test", "prisma.testTransaction"),
-			);
-		});
+			),
+		);
 
 	const layer = (layerOptions: Options): Layer.Layer<DatabaseId, PrismaError> => {
 		const acquire = Effect.acquireRelease(

package/src/internal/database-types.ts

@@ -1,7 +1,7 @@
 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 { 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>>;
@@ -45,20 +45,16 @@ type DatabaseModels<Contract extends AnySqlContract, Identifier extends string>
 };
 
 export type DatabaseService<Contract extends AnySqlContract, Identifier extends string> = DatabaseModels<Contract, Identifier> & {
-	transaction<A, E, R>(
+	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>>>;
+	) => 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;
+	readonly layer: (...arguments_: readonly never[]) => Layer.Any;
 };
 
 export type DatabaseServiceOf<Database extends AnyDatabase> = Effect.Success<Database>;

package/src/internal/dynamic.ts

@@ -3,7 +3,7 @@ const isObjectLike = (value: unknown): value is object => (typeof value === "obj
 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 => {
+export const invokeMethod = (target: object, name: PropertyKey, arguments_: readonly unknown[]): unknown => {
 	const method: unknown = Reflect.get(target, name);
 	if (typeof method !== "function") {
 		throw new TypeError(`${String(name)} is not a method`);

package/src/internal/executor.ts

@@ -6,15 +6,11 @@ import type { Semaphore } from "effect";
 export type AnySqlContract = PrismaContract<SqlStorage>;
 export type AnyPostgresContract = AnySqlContract;
 
-/**
- * The subset of a Prisma Next client the package depends on. Both the
- * PostgreSQL and the SQLite client satisfy it.
- */
 export interface SqlDatabaseClient<Contract extends AnySqlContract> {
-	readonly contract: Contract;
+	close: () => Promise<void>;
 	readonly context: ExecutionContext<Contract>;
-	runtime(): Runtime;
-	close(): Promise<void>;
+	readonly contract: Contract;
+	runtime: () => Runtime;
 }
 
 export interface DatabaseExecutor<Models extends object, Contract extends AnySqlContract = AnySqlContract> {

package/src/internal/promise.ts

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

package/src/internal/query-execution.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { type PrismaError, toPrismaError } from "../error.ts";
+import { type PrismaError, toPrismaError } from "#error.ts";
 import type { DatabaseExecutor } from "./executor.ts";
 
 export const executeQuery = <A, E, R>(

package/src/internal/recipe.ts

@@ -2,29 +2,29 @@ import { hasMethod, invokeMethod } from "./dynamic.ts";
 import { getRelationPlan, type RelationPlan } from "./relation-plan.ts";
 
 export interface RelationOperation {
+	readonly arguments: readonly unknown[];
 	readonly name: PropertyKey;
-	readonly arguments: ReadonlyArray<unknown>;
 }
 
 export interface RelationRecipe {
 	readonly model: string;
-	readonly parent?: RelationRecipe;
 	readonly operation?: RelationOperation;
+	readonly parent?: 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_: readonly unknown[]): RelationRecipe => ({
 	model: parent.model,
-	parent,
 	operation: {
-		name,
 		arguments: arguments_,
+		name,
 	},
+	parent,
 });
 
-const operations = (recipe: RelationRecipe): ReadonlyArray<RelationOperation> => {
-	const reversed: Array<RelationOperation> = [];
+const operations = (recipe: RelationRecipe): readonly RelationOperation[] => {
+	const reversed: RelationOperation[] = [];
 	let current: RelationRecipe | undefined = recipe;
 
 	while (current !== undefined) {
@@ -37,7 +37,7 @@ const operations = (recipe: RelationRecipe): ReadonlyArray<RelationOperation> =>
 	return reversed.reverse();
 };
 
-const applyMethod = (current: unknown, name: PropertyKey, arguments_: ReadonlyArray<unknown>, model: string): unknown => {
+const 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}`);
 	}

package/src/internal/relation-result.ts

@@ -1,5 +1,5 @@
 import { Effect, Option } from "effect";
-import type { PrismaError } from "../error.ts";
+import type { PrismaError } from "#error.ts";
 import { hasMethod, invokeMethod, isPromiseLike } from "./dynamic.ts";
 import { fromPrismaPromise } from "./promise.ts";
 
@@ -10,7 +10,7 @@ const countOf = (result: unknown): unknown => (typeof result === "object" && res
 
 export const evaluateResult = (value: unknown, terminal: PropertyKey | undefined): Effect.Effect<unknown, PrismaError> => {
 	if (terminal === "count" && hasMethod(value, "aggregate")) {
-		return settle(invokeMethod(value, "aggregate", [(summary: { count(): unknown }) => ({ count: summary.count() })]), countOf);
+		return settle(invokeMethod(value, "aggregate", [(summary: { count: () => unknown }) => ({ count: summary.count() })]), countOf);
 	}
 
 	if (terminal === "exists" && hasMethod(value, "first")) {

package/src/internal/relation-runtime.ts

@@ -1,6 +1,6 @@
 import { Effect, Effectable, type Stream } from "effect";
-import type { PrismaError } from "../error.ts";
-import type { Relation } from "../relation.ts";
+import type { PrismaError } from "#error.ts";
+import type { Relation } from "#relation.ts";
 import type { AnyPostgresContract, DatabaseExecutor } from "./executor.ts";
 import { executeQuery } from "./query-execution.ts";
 import { appendOperation, type RelationRecipe, replayRecipe, rootRecipe } from "./recipe.ts";
@@ -42,22 +42,22 @@ const relationEffect = (self: object): Effect.Effect<unknown, PrismaError> => {
 		),
 	).pipe(
 		Effect.withSpan(`prisma.${runtime.recipe.model}.${String(runtime.terminal ?? "all")}`, {
-			kind: "client",
 			attributes: {
-				"db.system": "postgresql",
 				"db.model": runtime.recipe.model,
 				"db.operation": String(runtime.terminal ?? "all"),
+				"db.system": "postgresql",
 			},
+			kind: "client",
 		}),
 	);
 };
 
 const RelationPrototype = {
 	...Effectable.Prototype<RelationValue>({
-		label: "EffectPrismaRelation",
 		evaluate() {
 			return relationEffect(this);
 		},
+		label: "EffectPrismaRelation",
 	}),
 	get stream(): Stream.Stream<unknown, PrismaError> {
 		const runtime = runtimeOf(this);
@@ -89,7 +89,7 @@ const makeRelationProxy = (runtime: AnyRelationRuntime): object => {
 						terminal: "count",
 					});
 			}
-			return (...arguments_: ReadonlyArray<unknown>) =>
+			return (...arguments_: readonly unknown[]) =>
 				makeRelationProxy({
 					...runtime,
 					recipe: appendOperation(runtime.recipe, property, arguments_),

package/src/internal/relation-stream.ts

@@ -1,14 +1,14 @@
 import { Effect, Stream } from "effect";
-import { isPrismaFailure, type PrismaError, toPrismaError } from "../error.ts";
+import { isPrismaFailure, type PrismaError, toPrismaError } from "#error.ts";
 import { hasMethod, invokeMethod, isAsyncIterable } from "./dynamic.ts";
 import type { AnyPostgresContract, DatabaseExecutor } from "./executor.ts";
 import { fromPrismaPromise } from "./promise.ts";
 import { executeQuery } from "./query-execution.ts";
 import { type RelationRecipe, replayRecipe } from "./recipe.ts";
 
-const collectRows = (iterable: AsyncIterable<unknown>): Effect.Effect<Array<unknown>, PrismaError> =>
+const collectRows = (iterable: AsyncIterable<unknown>): Effect.Effect<unknown[], PrismaError> =>
 	fromPrismaPromise(async () => {
-		const rows: Array<unknown> = [];
+		const rows: unknown[] = [];
 		for await (const row of iterable) {
 			rows.push(row);
 		}
@@ -18,8 +18,8 @@ const collectRows = (iterable: AsyncIterable<unknown>): Effect.Effect<Array<unkn
 export const makeRelationStream = <Models extends object, Contract extends AnyPostgresContract>(
 	resolveExecutor: Effect.Effect<DatabaseExecutor<Models, Contract>, PrismaError>,
 	recipe: RelationRecipe,
-): Stream.Stream<unknown, PrismaError> => {
-	return Stream.unwrap(
+): Stream.Stream<unknown, PrismaError> =>
+	Stream.unwrap(
 		Effect.flatMap(resolveExecutor, (executor) =>
 			executeQuery(
 				executor,
@@ -43,4 +43,3 @@ export const makeRelationStream = <Models extends object, Contract extends AnyPo
 			),
 		),
 	);
-};

package/src/internal/sqlite-datetime.ts

@@ -8,44 +8,23 @@ type CodecJson = Parameters<ContractCodec["decodeJson"]>[0];
 
 const sqliteDatetimeCodecId = "sqlite/datetime@1";
 
-const zonelessDatetime = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?)$/;
+const zonelessDatetime = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?)$/u;
 
-/**
- * Stamp `Z` onto a SQLite datetime string that carries no zone designator.
- *
- * SQLite stores `DateTime` as text and computes `datetime('now')` — the default
- * `prisma-next db init` generates — in UTC, but writes it as
- * `YYYY-MM-DD HH:MM:SS` with no zone. `new Date` reads that form as local time,
- * so decoding it unchanged shifts the instant by the process' UTC offset.
- * Values that already carry `Z` or a numeric offset, date-only values (which
- * `new Date` already reads as UTC), and anything that is not a datetime string
- * are returned unchanged.
- */
+// SQLite computes `datetime('now')`, the default `prisma-next db init` generates, in UTC but writes it as `YYYY-MM-DD HH:MM:SS`
+// with no zone, and `new Date` reads that form as local time. Values with a zone and date-only values already read as UTC.
 export const normalizeSqliteDatetime = (value: string): string => value.replace(zonelessDatetime, "$1T$2Z");
 
 const decodeAsUtc = (codec: ContractCodec): ContractCodec => ({
-	id: sqliteDatetimeCodecId,
-	encode: (value, context) => codec.encode(value, context),
 	decode: (wire: CodecWire, context) => codec.decode(typeof wire === "string" ? normalizeSqliteDatetime(wire) : wire, context),
-	encodeJson: (value) => codec.encodeJson(value),
 	decodeJson: (json: CodecJson) => codec.decodeJson(typeof json === "string" ? normalizeSqliteDatetime(json) : json),
+	encode: (value, context) => codec.encode(value, context),
+	encodeJson: (value) => codec.encodeJson(value),
+	id: sqliteDatetimeCodecId,
 });
 
-/**
- * Replace the client's codec registry with one that decodes zone-less
- * `sqlite/datetime@1` values as UTC.
- *
- * The registry is the single resolution point for both row decoding and the
- * JSON decoding of included relations, so wrapping it covers every read path
- * without touching encoding. Prisma Next rejects a second descriptor for an
- * already-registered codec id, so an extension pack cannot replace the codec
- * itself. Must run before the first query, because the runtime reads the
- * registry off the context when it is created.
- *
- * Codecs are identified by the resolved reference rather than by `codec.id`:
- * Prisma Next materializes a codec through an unbound descriptor factory, so
- * the instance's `id` accessor throws.
- */
+// The registry resolves codecs for rows and included relations alike, and Prisma Next rejects a second descriptor for a registered
+// codec id, so wrapping the registry is the one way to cover every read. It must run before the first query, which reads the
+// registry off the context. Codecs are matched by reference because a materialized codec's `id` accessor throws.
 export const decodeSqliteDatetimesAsUtc = (context: ExecutionContext<AnySqlContract>): void => {
 	const registry = context.contractCodecs;
 	const descriptors = context.codecDescriptors;
@@ -62,6 +41,10 @@ export const decodeSqliteDatetimesAsUtc = (context: ExecutionContext<AnySqlContr
 	};
 
 	const utcRegistry: CodecRegistry = {
+		forCodecRef: (reference) => {
+			const codec = registry.forCodecRef(reference);
+			return reference.codecId === sqliteDatetimeCodecId ? wrap(codec) : codec;
+		},
 		forColumn: (namespaceId, table, column) => {
 			const codec = registry.forColumn(namespaceId, table, column);
 			if (codec === undefined) {
@@ -70,10 +53,6 @@ export const decodeSqliteDatetimesAsUtc = (context: ExecutionContext<AnySqlContr
 			const reference = descriptors.codecRefForColumn(namespaceId, table, column);
 			return reference?.codecId === sqliteDatetimeCodecId ? wrap(codec) : codec;
 		},
-		forCodecRef: (reference) => {
-			const codec = registry.forCodecRef(reference);
-			return reference.codecId === sqliteDatetimeCodecId ? wrap(codec) : codec;
-		},
 	};
 
 	if (!Reflect.set(context, "contractCodecs", utcRegistry)) {

package/src/internal/sqlite-pragmas.ts

@@ -2,11 +2,7 @@ import { DatabaseSync } from "node:sqlite";
 
 export const MEMORY_PATH = ":memory:";
 
-/**
- * Prisma Next's SQLite driver opens a fresh `node:sqlite` connection for every
- * `RuntimeConnection`, so an in-memory database would give each transaction its
- * own empty database.
- */
+// Prisma Next's SQLite driver opens a fresh `node:sqlite` connection per `RuntimeConnection`, so each transaction would get its own empty in-memory database.
 export const assertFileBackedPath = (path: string): void => {
 	if (path === MEMORY_PATH || path.trim().length === 0) {
 		throw new TypeError(
@@ -15,14 +11,8 @@ export const assertFileBackedPath = (path: string): void => {
 	}
 };
 
-/**
- * Apply connect-time pragmas.
- *
- * The driver already sets `foreign_keys` and `busy_timeout` on every connection
- * it opens, but it has no hook for anything else, so durable pragmas such as
- * `journal_mode` are applied once against the database file itself.
- */
-export const applySqlitePragmas = (path: string, pragmas: ReadonlyArray<string>): void => {
+// The driver has no hook for pragmas beyond `foreign_keys` and `busy_timeout`, so durable ones such as `journal_mode` go to the file once.
+export const applySqlitePragmas = (path: string, pragmas: readonly string[]): void => {
 	if (pragmas.length === 0) {
 		return;
 	}

package/src/internal/testing.ts

@@ -1,5 +1,5 @@
 import type { Effect } from "effect";
-import type { PrismaError } from "../error.ts";
+import type { PrismaError } from "#error.ts";
 
 export const DatabaseTestingTypeId: unique symbol = Symbol.for("@shivaedev/effect-prisma/DatabaseTesting");
 

package/src/internal/transaction.ts

@@ -1,7 +1,7 @@
 import { orm } from "@prisma-next/sql-orm-client";
 import { Effect, Exit, Semaphore } from "effect";
-import type { PrismaError } from "../error.ts";
-import { type SettledConnection, type SettledTransaction, settleConnection } from "./adapters/transaction-settlement.ts";
+import type { PrismaError } from "#error.ts";
+import { type SettledConnection, type SettledTransaction, settleConnection } from "#internal/adapters/transaction-settlement.ts";
 import type { AnySqlContract, DatabaseExecutor } from "./executor.ts";
 import { fromPrismaPromise } from "./promise.ts";
 
@@ -14,10 +14,10 @@ export const withTransactionSemaphore = <A, E, R>(
 
 export interface TransactionResource<Models extends object, Contract extends AnySqlContract> {
 	readonly connection: SettledConnection;
-	readonly transaction: SettledTransaction;
 	readonly executor: DatabaseExecutor<Models, Contract> & {
 		readonly querySemaphore: Semaphore.Semaphore;
 	};
+	readonly transaction: SettledTransaction;
 }
 
 export const acquireTransaction = <Models extends object, Contract extends AnySqlContract>(
@@ -31,13 +31,12 @@ export const acquireTransaction = <Models extends object, Contract extends AnySq
 		try {
 			const transaction = await connection.transaction();
 			const transactionOrm = orm({
-				runtime: transaction,
 				context: current.client.context,
+				runtime: transaction,
 			});
 
 			return {
 				connection,
-				transaction,
 				executor: {
 					client: current.client,
 					identity: current.identity,
@@ -51,6 +50,7 @@ export const acquireTransaction = <Models extends object, Contract extends AnySq
 					transactionIdentity: {},
 					transactionSemaphore: current.transactionSemaphore,
 				},
+				transaction,
 			};
 		} catch (error) {
 			await connection.destroy(error).catch(() => undefined);

package/src/relation/include-metadata.ts

@@ -62,7 +62,7 @@ type AnyNullableField<Fields, Names extends readonly string[]> = Names extends r
 
 export type IncludedRelationValue<Contract extends AnyPostgresContract, Model extends string, RelationName extends string, Value> =
 	RelationCardinalityOf<Contract, Model, RelationName> extends "1:N" | "N:M"
-		? Array<Value>
+		? Value[]
 		: RelationCardinalityOf<Contract, Model, RelationName> extends "N:1"
 			? AnyNullableField<ModelFields<Contract, Model>, RelationLocalFields<Contract, Model, RelationName>> extends true
 				? Value | null

package/src/relation/include.ts

@@ -1,5 +1,5 @@
 import type { DefaultModelRow, Collection as PrismaCollection, RelationNames } from "@prisma-next/sql-orm-client";
-import type { Relation, RelationQuery } from "../relation.ts";
+import type { Relation, RelationQuery } from "#relation.ts";
 import type { AnyPostgresContract, IncludedRelationValue, IsToManyRelation, RelatedModelNameOf } from "./include-metadata.ts";
 
 type Simplify<Value> = { [Key in keyof Value]: Value[Key] };
@@ -43,40 +43,42 @@ type WithIncludedRelation<Collection, Contract extends AnyPostgresContract, Mode
 		? PrismaCollection<Contract, Model, Simplify<Row & { readonly [Key in RelationName]: Value }>, State>
 		: never;
 
+interface IncludeOverloads<Collection, Contract extends AnyPostgresContract, Model extends string, DatabaseId> {
+	<RelationName extends RelationNames<Contract, Model>>(
+		relationName: RelationName,
+	): Relation<
+		WithIncludedRelation<
+			Collection,
+			Contract,
+			Model,
+			RelationName,
+			IncludedRelationValue<Contract, Model, RelationName, DefaultModelRow<Contract, RelatedModelNameOf<Contract, Model, RelationName>>>
+		>,
+		Contract,
+		Model,
+		DatabaseId
+	>;
+	<RelationName extends RelationNames<Contract, Model>, Query>(
+		relationName: RelationName,
+		query: Query & AcceptRelatedQuery<Query, Contract, RelatedModelNameOf<Contract, Model, RelationName>, DatabaseId>,
+	): Relation<
+		WithIncludedRelation<Collection, Contract, Model, RelationName, IncludedQueryValue<Query, Contract, Model, RelationName>>,
+		Contract,
+		Model,
+		DatabaseId
+	>;
+	<RelationName extends RelationNames<Contract, Model>, Shape extends Readonly<Record<string, unknown>>>(
+		relationName: RelationName,
+		shape: IsToManyRelation<Contract, Model, RelationName> extends true
+			? keyof Shape extends never
+				? never
+				: Shape & AcceptRelatedQueryShape<Shape, Contract, RelatedModelNameOf<Contract, Model, RelationName>, DatabaseId>
+			: never,
+	): Relation<WithIncludedRelation<Collection, Contract, Model, RelationName, QueryShapeValue<Shape>>, Contract, Model, DatabaseId>;
+}
+
 export type IncludeMethod<Collection, Contract, Model extends string, DatabaseId> = Contract extends AnyPostgresContract
 	? Collection extends PrismaCollection<Contract, Model, infer _Row, infer _State>
-		? {
-				include<RelationName extends RelationNames<Contract, Model>>(
-					relationName: RelationName,
-				): Relation<
-					WithIncludedRelation<
-						Collection,
-						Contract,
-						Model,
-						RelationName,
-						IncludedRelationValue<Contract, Model, RelationName, DefaultModelRow<Contract, RelatedModelNameOf<Contract, Model, RelationName>>>
-					>,
-					Contract,
-					Model,
-					DatabaseId
-				>;
-				include<RelationName extends RelationNames<Contract, Model>, Query>(
-					relationName: RelationName,
-					query: Query & AcceptRelatedQuery<Query, Contract, RelatedModelNameOf<Contract, Model, RelationName>, DatabaseId>,
-				): Relation<
-					WithIncludedRelation<Collection, Contract, Model, RelationName, IncludedQueryValue<Query, Contract, Model, RelationName>>,
-					Contract,
-					Model,
-					DatabaseId
-				>;
-				include<RelationName extends RelationNames<Contract, Model>, Shape extends Readonly<Record<string, unknown>>>(
-					relationName: RelationName,
-					shape: IsToManyRelation<Contract, Model, RelationName> extends true
-						? keyof Shape extends never
-							? never
-							: Shape & AcceptRelatedQueryShape<Shape, Contract, RelatedModelNameOf<Contract, Model, RelationName>, DatabaseId>
-						: never,
-				): Relation<WithIncludedRelation<Collection, Contract, Model, RelationName, QueryShapeValue<Shape>>, Contract, Model, DatabaseId>;
-			}
+		? { include: IncludeOverloads<Collection, Contract, Model, DatabaseId> }
 		: Record<never, never>
 	: Record<never, never>;

package/src/relation/prisma-methods.ts

@@ -9,11 +9,11 @@ import type {
 	Collection as PrismaCollection,
 } from "@prisma-next/sql-orm-client";
 import type { Effect, Stream } from "effect";
-import type { PrismaError } from "../error.ts";
-import type { CollectionResult, Relation, RelationQuery } from "../relation.ts";
+import type { PrismaError } from "#error.ts";
+import type { CollectionResult, Relation, RelationQuery } from "#relation.ts";
 import type { IncludeMethod } from "./include.ts";
 
-type AnyFunction = (...arguments_: ReadonlyArray<never>) => unknown;
+type AnyFunction = (...arguments_: readonly never[]) => unknown;
 type AnyPostgresContract = PrismaContract<SqlStorage>;
 type FieldTuple<Row> = readonly [keyof Row & string, ...(keyof Row & string)[]];
 type Simplify<Value> = { [Key in keyof Value]: Value[Key] };
@@ -25,9 +25,9 @@ type TerminalMethod<Method> = Method extends (...arguments_: infer Arguments) =>
 type SelectMethod<Collection, Contract, Model extends string, DatabaseId> = Contract extends AnyPostgresContract
 	? Collection extends PrismaCollection<Contract, Model, infer _Row, infer State>
 		? {
-				select<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
+				select: <Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
 					...fields: Fields
-				): Relation<PrismaCollection<Contract, Model, Pick<DefaultModelRow<Contract, Model>, Fields[number]>, State>, Contract, Model, DatabaseId>;
+				) => Relation<PrismaCollection<Contract, Model, Pick<DefaultModelRow<Contract, Model>, Fields[number]>, State>, Contract, Model, DatabaseId>;
 			}
 		: Record<never, never>
 	: Collection extends { select: infer Select extends AnyFunction }
@@ -46,16 +46,16 @@ type AggregateConfigure<Collection> = Collection extends {
 
 type AggregateSuccess<Collection, Contract extends AnyPostgresContract, Model extends string, Spec extends AggregateSpec> =
 	Collection extends GroupedCollection<Contract, Model, infer Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>
-		? Array<Simplify<Pick<DefaultModelRow<Contract, Model>, Fields[number]> & AggregateResult<Spec>>>
+		? Simplify<Pick<DefaultModelRow<Contract, Model>, Fields[number]> & AggregateResult<Spec>>[]
 		: AggregateResult<Spec>;
 
 type AggregateMethod<Collection, Contract, Model extends string> = Contract extends AnyPostgresContract
 	? Collection extends { aggregate: AnyFunction }
 		? {
-				aggregate<Spec extends AggregateSpec>(
+				aggregate: <Spec extends AggregateSpec>(
 					make: (aggregate: AggregateBuilder<Contract, Model>) => Spec,
 					configure?: AggregateConfigure<Collection>,
-				): Effect.Effect<AggregateSuccess<Collection, Contract, Model, Spec>, PrismaError>;
+				) => Effect.Effect<AggregateSuccess<Collection, Contract, Model, Spec>, PrismaError>;
 			}
 		: Record<never, never>
 	: Record<never, never>;
@@ -63,16 +63,18 @@ type AggregateMethod<Collection, Contract, Model extends string> = Contract exte
 type CollectionMethods<Collection, Contract, Model extends string, DatabaseId> = Contract extends AnyPostgresContract
 	? Collection extends PrismaCollection<Contract, Model, infer _Row, infer State>
 		? {
-				groupBy<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
+				groupBy: <Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
 					...fields: Fields
-				): Relation<GroupedCollection<Contract, Model, Fields>, Contract, Model, DatabaseId>;
-				cursor(
+				) => Relation<GroupedCollection<Contract, Model, Fields>, Contract, Model, DatabaseId>;
+				cursor: (
 					values: State extends { readonly hasOrderBy: true } ? Partial<Record<keyof DefaultModelRow<Contract, Model> & string, unknown>> : never,
-				): Relation<Collection, Contract, Model, DatabaseId>;
-				distinct<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(...fields: Fields): Relation<Collection, Contract, Model, DatabaseId>;
-				distinctOn<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
+				) => Relation<Collection, Contract, Model, DatabaseId>;
+				distinct: <Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
+					...fields: Fields
+				) => Relation<Collection, Contract, Model, DatabaseId>;
+				distinctOn: <Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
 					...fields: State extends { readonly hasOrderBy: true } ? Fields : never
-				): Relation<Collection, Contract, Model, DatabaseId>;
+				) => Relation<Collection, Contract, Model, DatabaseId>;
 			} & (State extends { readonly hasWhere: true }
 				? {
 						readonly [Key in "delete" | "deleteAll" | "deleteCount"]: TerminalMethod<Collection[Key]>;
@@ -85,15 +87,15 @@ type CollectionConveniences<Collection, Contract, Model extends string, Database
 	? Collection extends PrismaCollection<Contract, Model, infer Row, infer _State>
 		? {
 				readonly stream: Stream.Stream<Row, PrismaError>;
-				count(): RelationQuery<number, Contract, Model, DatabaseId>;
-				exists(): Effect.Effect<boolean, PrismaError>;
+				count: () => RelationQuery<number, Contract, Model, DatabaseId>;
+				exists: () => Effect.Effect<boolean, PrismaError>;
 			}
 		: Record<never, never>
 	: CollectionResult<Collection> extends ReadonlyArray<infer Row>
 		? {
 				readonly stream: Stream.Stream<Row, PrismaError>;
-				count(): Effect.Effect<number, PrismaError>;
-				exists(): Effect.Effect<boolean, PrismaError>;
+				count: () => Effect.Effect<number, PrismaError>;
+				exists: () => Effect.Effect<boolean, PrismaError>;
 			}
 		: Record<never, never>;
 

package/src/relation.ts

@@ -1,11 +1,11 @@
 import type { Effect } from "effect";
+import type { PrismaRelationMethods } from "#relation/prisma-methods.ts";
 import type { PrismaError } from "./error.ts";
-import type { PrismaRelationMethods } from "./relation/prisma-methods.ts";
 
-type AnyFunction = (...arguments_: ReadonlyArray<never>) => unknown;
+type AnyFunction = (...arguments_: readonly never[]) => unknown;
 
 export type CollectionResult<Collection> = Collection extends {
-	all(): infer Result;
+	all: () => infer Result;
 }
 	? Awaited<Result>
 	: never;