@shivaedev/effect-prisma 0.6.3 → 0.7.0

package/src/relation/prisma-methods.ts

@@ -9,57 +9,31 @@ import type {
 	Collection as PrismaCollection,
 } from "@prisma-next/sql-orm-client";
 import type { Effect, Stream } from "effect";
-import type { PrismaError } from "../error.js";
-import type { CollectionResult, Relation, RelationQuery } from "../relation.js";
-import type { IncludeMethod } from "./include.js";
+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] };
 
-type TerminalMethod<Method> = Method extends (
-	...arguments_: infer Arguments
-) => PromiseLike<infer Value>
+type TerminalMethod<Method> = Method extends (...arguments_: infer Arguments) => PromiseLike<infer Value>
 	? (...arguments_: Arguments) => Effect.Effect<Awaited<Value>, PrismaError>
 	: never;
 
-type SelectMethod<
-	Collection,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = Contract extends AnyPostgresContract
-	? Collection extends PrismaCollection<
-			Contract,
-			Model,
-			infer _Row,
-			infer State
-		>
+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 }
 		? {
 				select: Select extends (...arguments_: infer Arguments) => infer Result
-					? (
-							...arguments_: Arguments
-						) => Result extends object
-							? Relation<Result, Contract, Model, DatabaseId>
-							: never
+					? (...arguments_: Arguments) => Result extends object ? Relation<Result, Contract, Model, DatabaseId> : never
 					: never;
 			}
 		: Record<never, never>;
@@ -70,122 +44,62 @@ type AggregateConfigure<Collection> = Collection extends {
 	? Exclude<Parameters<Method>[1], undefined>
 	: never;
 
-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>
-				>
-			>
+type AggregateSuccess<Collection, Contract extends AnyPostgresContract, Model extends string, Spec extends AggregateSpec> =
+	Collection extends GroupedCollection<Contract, Model, infer Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>
+		? Simplify<Pick<DefaultModelRow<Contract, Model>, Fields[number]> & AggregateResult<Spec>>[]
 		: AggregateResult<Spec>;
 
-type AggregateMethod<
-	Collection,
-	Contract,
-	Model extends string,
-> = Contract extends AnyPostgresContract
+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>;
 
-type CollectionMethods<
-	Collection,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = Contract extends AnyPostgresContract
-	? Collection extends PrismaCollection<
-			Contract,
-			Model,
-			infer _Row,
-			infer State
-		>
+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(
-					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>>>(
+				) => 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>>>(
-					...fields: State extends { readonly hasOrderBy: true }
-						? Fields
-						: never
-				): Relation<Collection, Contract, Model, DatabaseId>;
+				) => 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>;
 			} & (State extends { readonly hasWhere: true }
 				? {
-						readonly [Key in
-							| "delete"
-							| "deleteAll"
-							| "deleteCount"]: TerminalMethod<Collection[Key]>;
+						readonly [Key in "delete" | "deleteAll" | "deleteCount"]: TerminalMethod<Collection[Key]>;
 					}
 				: Record<never, never>)
 		: Record<never, never>
 	: Record<never, never>;
 
-type CollectionConveniences<
-	Collection,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = Contract extends AnyPostgresContract
-	? Collection extends PrismaCollection<
-			Contract,
-			Model,
-			infer Row,
-			infer _State
-		>
+type CollectionConveniences<Collection, Contract, Model extends string, DatabaseId> = Contract extends AnyPostgresContract
+	? 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>;
 
-export type PrismaRelationMethods<
-	Collection,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = SelectMethod<Collection, Contract, Model, DatabaseId> &
+export type PrismaRelationMethods<Collection, Contract, Model extends string, DatabaseId> = SelectMethod<Collection, Contract, Model, DatabaseId> &
 	IncludeMethod<Collection, Contract, Model, DatabaseId> &
 	AggregateMethod<Collection, Contract, Model> &
 	CollectionMethods<Collection, Contract, Model, DatabaseId> &

package/src/relation.ts

@@ -1,18 +1,16 @@
 import type { Effect } from "effect";
-import type { PrismaError } from "./error.js";
-import type { PrismaRelationMethods } from "./relation/prisma-methods.js";
+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;
 
-type NormalizeTerminal<Name, Result> = Name extends "first"
-	? import("effect").Option.Option<Exclude<Result, null>>
-	: Result;
+type NormalizeTerminal<Name, Result> = Name extends "first" ? import("effect").Option.Option<Exclude<Result, null>> : Result;
 
 type WrapReturn<Name, Result, Contract, Model extends string, DatabaseId> =
 	Result extends PromiseLike<infer Value>
@@ -21,13 +19,7 @@ type WrapReturn<Name, Result, Contract, Model extends string, DatabaseId> =
 			? Relation<Result, Contract, Model, DatabaseId>
 			: never;
 
-type WrapFunction<
-	Name,
-	Function_,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = Function_ extends {
+type WrapFunction<Name, Function_, Contract, Model extends string, DatabaseId> = Function_ extends {
 	(...arguments_: infer Arguments1): infer Result1;
 	(...arguments_: infer Arguments2): infer Result2;
 	(...arguments_: infer Arguments3): infer Result3;
@@ -35,24 +27,12 @@ type WrapFunction<
 	(...arguments_: infer Arguments5): infer Result5;
 	(...arguments_: infer Arguments6): infer Result6;
 }
-	? ((
-			...arguments_: Arguments1
-		) => WrapReturn<Name, Result1, Contract, Model, DatabaseId>) &
-			((
-				...arguments_: Arguments2
-			) => WrapReturn<Name, Result2, Contract, Model, DatabaseId>) &
-			((
-				...arguments_: Arguments3
-			) => WrapReturn<Name, Result3, Contract, Model, DatabaseId>) &
-			((
-				...arguments_: Arguments4
-			) => WrapReturn<Name, Result4, Contract, Model, DatabaseId>) &
-			((
-				...arguments_: Arguments5
-			) => WrapReturn<Name, Result5, Contract, Model, DatabaseId>) &
-			((
-				...arguments_: Arguments6
-			) => WrapReturn<Name, Result6, Contract, Model, DatabaseId>)
+	? ((...arguments_: Arguments1) => WrapReturn<Name, Result1, Contract, Model, DatabaseId>) &
+			((...arguments_: Arguments2) => WrapReturn<Name, Result2, Contract, Model, DatabaseId>) &
+			((...arguments_: Arguments3) => WrapReturn<Name, Result3, Contract, Model, DatabaseId>) &
+			((...arguments_: Arguments4) => WrapReturn<Name, Result4, Contract, Model, DatabaseId>) &
+			((...arguments_: Arguments5) => WrapReturn<Name, Result5, Contract, Model, DatabaseId>) &
+			((...arguments_: Arguments6) => WrapReturn<Name, Result6, Contract, Model, DatabaseId>)
 	: never;
 
 type FunctionKeys<Value> = {
@@ -79,20 +59,12 @@ type ExplicitPrismaMethod =
 	| "variant";
 
 type RelationMethods<Collection, Contract, Model extends string, DatabaseId> = {
-	readonly [Key in Exclude<
-		FunctionKeys<Collection>,
-		ExplicitPrismaMethod
-	>]: WrapFunction<Key, Collection[Key], Contract, Model, DatabaseId>;
+	readonly [Key in Exclude<FunctionKeys<Collection>, ExplicitPrismaMethod>]: WrapFunction<Key, Collection[Key], Contract, Model, DatabaseId>;
 };
 
 declare const RelationQueryTypeId: unique symbol;
 
-export type RelationQuery<
-	Value,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = Effect.Effect<Value, PrismaError> & {
+export type RelationQuery<Value, Contract, Model extends string, DatabaseId> = Effect.Effect<Value, PrismaError> & {
 	readonly [RelationQueryTypeId]: {
 		readonly contract: Contract;
 		readonly database: (database: DatabaseId) => DatabaseId;
@@ -100,11 +72,11 @@ export type RelationQuery<
 	};
 };
 
-export type Relation<
-	Collection,
-	Contract = undefined,
-	Model extends string = string,
-	DatabaseId = undefined,
-> = RelationQuery<CollectionResult<Collection>, Contract, Model, DatabaseId> &
+export type Relation<Collection, Contract = undefined, Model extends string = string, DatabaseId = undefined> = RelationQuery<
+	CollectionResult<Collection>,
+	Contract,
+	Model,
+	DatabaseId
+> &
 	RelationMethods<Collection, Contract, Model, DatabaseId> &
 	PrismaRelationMethods<Collection, Contract, Model, DatabaseId>;

package/src/sqlite.ts

@@ -1,38 +1,20 @@
-import sqlite, {
-	type SqliteClient,
-	type SqliteOptionsBase,
-} from "@prisma-next/sqlite/runtime";
+import sqlite, { type SqliteClient, type SqliteOptionsBase } from "@prisma-next/sqlite/runtime";
 import { type Layer, Semaphore } from "effect";
-import type { PrismaError } from "./error.js";
-import {
-	acquireConnectedClient,
-	assertAvailableModelNames,
-} from "./internal/client-lifecycle.js";
-import {
-	type DatabaseIdentifier,
-	type DatabaseIdentifierLiteral,
-	type DatabaseServiceHolder,
-	type DefaultModels,
-	makeSqlDatabase,
-} from "./internal/database-factory.js";
-import type { AnySqlContract } from "./internal/executor.js";
-import { fromPrismaPromise } from "./internal/promise.js";
-import { decodeSqliteDatetimesAsUtc } from "./internal/sqlite-datetime.js";
-import {
-	applySqlitePragmas,
-	assertFileBackedPath,
-} from "./internal/sqlite-pragmas.js";
+import type { PrismaError } from "./error.ts";
+import { acquireConnectedClient, assertAvailableModelNames } from "./internal/client-lifecycle.ts";
+import { contractModels } from "./internal/database-facade.ts";
+import { makeSqlDatabase } from "./internal/database-factory.ts";
+import type { DatabaseIdentifier, DatabaseIdentifierLiteral, DatabaseServiceHolder, DefaultModels } from "./internal/database-types.ts";
+import type { AnySqlContract } from "./internal/executor.ts";
+import { fromPrismaPromise } from "./internal/promise.ts";
+import { decodeSqliteDatetimesAsUtc } from "./internal/sqlite-datetime.ts";
+import { applySqlitePragmas, assertFileBackedPath } from "./internal/sqlite-pragmas.ts";
 
-export const defaultSqlitePragmas: ReadonlyArray<string> = ["journal_mode=WAL"];
+export const defaultSqlitePragmas: readonly string[] = ["journal_mode=WAL"];
 
 export interface SqliteDatabaseLayerOptions extends SqliteOptionsBase {
-	/** Path to the database file. In-memory databases are not supported. */
 	readonly path: string;
-	/**
-	 * Pragmas applied once when the Layer connects. Defaults to
-	 * {@link defaultSqlitePragmas}; pass `[]` to skip them.
-	 */
-	readonly pragmas?: ReadonlyArray<string>;
+	readonly pragmas?: readonly string[];
 }
 
 type SqliteFactoryOptions<Contract extends AnySqlContract> =
@@ -45,15 +27,18 @@ type SqliteFactoryOptions<Contract extends AnySqlContract> =
 			readonly contract?: never;
 	  };
 
-export interface SqliteDatabaseDefinition<
-	Contract extends AnySqlContract,
-	Identifier extends string,
-> extends DatabaseServiceHolder<Contract, Identifier> {
-	readonly layer: (
-		options: SqliteDatabaseLayerOptions,
-	) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
+export interface SqliteDatabaseDefinition<Contract extends AnySqlContract, Identifier extends string>
+	extends DatabaseServiceHolder<Contract, Identifier> {
+	readonly layer: (options: SqliteDatabaseLayerOptions) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
 }
 
+const clientOptions = ({ path, extensions, middleware, verifyMarker }: SqliteDatabaseLayerOptions) => ({
+	path,
+	...(extensions === undefined ? {} : { extensions }),
+	...(middleware === undefined ? {} : { middleware }),
+	...(verifyMarker === undefined ? {} : { verifyMarker }),
+});
+
 export const makeSqliteDatabase =
 	<const Contract extends AnySqlContract>() =>
 	<const Identifier extends string>(
@@ -62,55 +47,44 @@ export const makeSqliteDatabase =
 	): SqliteDatabaseDefinition<Contract, Identifier> => {
 		type Models = DefaultModels<Contract>;
 
-		return makeSqlDatabase<Contract, Identifier, SqliteDatabaseLayerOptions>(
-			identifier,
-			(layerOptions) => {
-				assertFileBackedPath(layerOptions.path);
-				applySqlitePragmas(
-					layerOptions.path,
-					layerOptions.pragmas ?? defaultSqlitePragmas,
-				);
+		return makeSqlDatabase<Contract, Identifier, SqliteDatabaseLayerOptions>(identifier, (layerOptions) => {
+			assertFileBackedPath(layerOptions.path);
+			applySqlitePragmas(layerOptions.path, layerOptions.pragmas ?? defaultSqlitePragmas);
 
-				const clientOptions = {
-					path: layerOptions.path,
-					extensions: layerOptions.extensions,
-					middleware: layerOptions.middleware,
-					verifyMarker: layerOptions.verifyMarker,
-				};
-				const client: SqliteClient<Contract> =
-					options.contract === undefined
-						? sqlite<Contract>({
-								...clientOptions,
-								contractJson: options.contractJson,
-							})
-						: sqlite<Contract>({
-								...clientOptions,
-								contract: options.contract,
-							});
+			const forwarded = clientOptions(layerOptions);
+			const client: SqliteClient<Contract> =
+				options.contract === undefined
+					? sqlite<Contract>({
+							...forwarded,
+							contractJson: options.contractJson,
+						})
+					: sqlite<Contract>({
+							...forwarded,
+							contract: options.contract,
+						});
 
-				decodeSqliteDatetimesAsUtc(client.context);
+			decodeSqliteDatetimesAsUtc(client.context);
 
-				return fromPrismaPromise(() =>
-					acquireConnectedClient(client, () => {
-						// The SQLite client already exposes the unbound namespace.
-						const models = client.orm as Models;
-						const accessSemaphore = Semaphore.makeUnsafe(1);
-						assertAvailableModelNames(Object.keys(models));
-						return {
-							client,
-							identity: {},
-							liveness: {
-								closedCode: "RUNTIME.DATABASE_CLOSED",
-								open: true,
-							},
-							mode: "root",
-							models,
-							querySemaphore: accessSemaphore,
-							transactionIdentity: undefined,
-							transactionSemaphore: accessSemaphore,
-						};
-					}),
-				);
-			},
-		) as SqliteDatabaseDefinition<Contract, Identifier>;
+			return fromPrismaPromise(() =>
+				acquireConnectedClient(client, () => {
+					// The SQLite client already exposes the unbound namespace.
+					const models = contractModels<Models>(client.orm);
+					const accessSemaphore = Semaphore.makeUnsafe(1);
+					assertAvailableModelNames(Object.keys(models));
+					return {
+						client,
+						identity: {},
+						liveness: {
+							closedCode: "RUNTIME.DATABASE_CLOSED",
+							open: true,
+						},
+						mode: "root",
+						models,
+						querySemaphore: accessSemaphore,
+						transactionIdentity: undefined,
+						transactionSemaphore: accessSemaphore,
+					};
+				}),
+			);
+		});
 	};

package/src/testing/transaction.ts

@@ -1,38 +1,25 @@
 import type { Effect } from "effect";
-import type { PrismaError } from "../error.js";
-import { getDatabaseTesting } from "../internal/testing.js";
-import type { AnyDatabase } from "./types.js";
+import type { PrismaError } from "../error.ts";
+import { getDatabaseTesting } from "../internal/testing.ts";
+import type { AnyDatabase } from "./types.ts";
 
-type WithTestTransaction = {
-	<Database extends AnyDatabase>(
-		database: Database,
-	): <A, E, R>(
-		program: Effect.Effect<A, E, R> &
-			(Effect.Services<Database> extends R ? unknown : never),
-	) => Effect.Effect<
-		A,
-		E | PrismaError,
-		Effect.Services<Database> | Exclude<R, Effect.Services<Database>>
-	>;
-	<Database extends AnyDatabase, A, E, R>(
-		database: Database,
-		program: Effect.Effect<A, E, R> &
-			(Effect.Services<Database> extends R ? unknown : never),
-	): Effect.Effect<
-		A,
-		E | PrismaError,
-		Effect.Services<Database> | Exclude<R, Effect.Services<Database>>
-	>;
-};
+type TestProgram<Database extends AnyDatabase, A, E, R> = Effect.Effect<A, E, R> & (Effect.Services<Database> extends R ? unknown : never);
 
-export const withTestTransaction: WithTestTransaction = ((
-	database: AnyDatabase,
-	program?: Effect.Effect<unknown, unknown, unknown>,
-) => {
-	const run = (effect: Effect.Effect<unknown, unknown, unknown>) =>
-		getDatabaseTesting<Effect.Services<typeof database>>(
-			database,
-		).withTestTransaction(effect);
+type TestTransaction<Database extends AnyDatabase, A, E, R> = Effect.Effect<
+	A,
+	E | PrismaError,
+	Effect.Services<Database> | Exclude<R, Effect.Services<Database>>
+>;
+
+export function withTestTransaction<Database extends AnyDatabase>(
+	database: Database,
+): <A, E, R>(program: TestProgram<Database, A, E, R>) => TestTransaction<Database, A, E, R>;
+export function withTestTransaction<Database extends AnyDatabase, A, E, R>(
+	database: Database,
+	program: TestProgram<Database, A, E, R>,
+): TestTransaction<Database, A, E, R>;
+export function withTestTransaction(database: AnyDatabase, program?: Effect.Effect<unknown, unknown, unknown>): unknown {
+	const run = (effect: Effect.Effect<unknown, unknown, unknown>) => getDatabaseTesting<unknown>(database).withTestTransaction(effect);
 
 	return program === undefined ? run : run(program);
-}) as WithTestTransaction;
+}

package/src/testing/types.ts

@@ -1,56 +1,37 @@
 import type { TestContext, Vitest } from "@effect/vitest";
-import type { EffectClock, EffectTestOptions } from "@shivaedev/effect-test";
 import type { Effect, Layer } from "effect";
-import type { AnyDatabase, DatabaseServiceOf } from "../database.js";
+import type { EffectClock, EffectTestOptions } from "@shivaedev/effect-test";
+import type { AnyDatabase, DatabaseServiceOf } from "../database.ts";
 
-export type { AnyDatabase } from "../database.js";
-export type DatabaseService<Database extends AnyDatabase> =
-	DatabaseServiceOf<Database>;
+export type { AnyDatabase } from "../database.ts";
+export type DatabaseService<Database extends AnyDatabase> = DatabaseServiceOf<Database>;
 
-export type DatabaseTest<Database extends AnyDatabase, Provided> = <
-	A,
-	Eff extends Effect.Effect<unknown, unknown, Provided>,
->(
+export type DatabaseTest<Database extends AnyDatabase, Provided> = <A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
 	name: string,
-	body: (
-		database: DatabaseService<Database>,
-		context: TestContext,
-	) => Generator<Eff, A, never>,
+	body: (database: DatabaseService<Database>, context: TestContext) => Generator<Eff, A, never>,
 	options?: number | EffectTestOptions,
 ) => void;
 
-export interface DatabaseTester<Database extends AnyDatabase, Provided>
-	extends DatabaseTest<Database, Provided> {
-	readonly skip: DatabaseTest<Database, Provided>;
-	readonly skipIf: (condition: unknown) => DatabaseTest<Database, Provided>;
-	readonly runIf: (condition: unknown) => DatabaseTest<Database, Provided>;
-	readonly only: DatabaseTest<Database, Provided>;
+export interface DatabaseTester<Database extends AnyDatabase, Provided> extends DatabaseTest<Database, Provided> {
 	readonly each: <Item>(
-		cases: ReadonlyArray<Item>,
+		cases: readonly Item[],
 	) => <A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
 		name: string,
-		body: (
-			item: Item,
-			database: DatabaseService<Database>,
-			context: TestContext,
-		) => Generator<Eff, A, never>,
+		body: (item: Item, database: DatabaseService<Database>, context: TestContext) => Generator<Eff, A, never>,
 		options?: number | EffectTestOptions,
 	) => void;
 	readonly fails: DatabaseTest<Database, Provided>;
+	readonly only: DatabaseTest<Database, Provided>;
+	readonly runIf: (condition: unknown) => DatabaseTest<Database, Provided>;
+	readonly skip: DatabaseTest<Database, Provided>;
+	readonly skipIf: (condition: unknown) => DatabaseTest<Database, Provided>;
 }
 
-export type DatabaseIt<
-	Database extends AnyDatabase,
-	Provided,
-> = Vitest.Methods & {
+export type DatabaseIt<Database extends AnyDatabase, Provided> = Vitest.Methods & {
 	readonly effectDB: DatabaseTester<Database, Provided>;
 };
 
-export interface MakeDatabaseItOptions<
-	Database extends AnyDatabase,
-	Provided,
-	LayerError,
-> {
+export interface MakeDatabaseItOptions<Database extends AnyDatabase, Provided, LayerError> {
 	readonly clock?: EffectClock;
 	readonly database: Database;
 	readonly layer: Layer.Layer<Provided, LayerError>;