@shivaedev/effect-prisma 0.0.0 → 0.1.0

package/src/relation/prisma-methods.ts

@@ -0,0 +1,192 @@
+import type { Contract as PrismaContract } from "@prisma-next/contract/types";
+import type { SqlStorage } from "@prisma-next/sql-contract/types";
+import type {
+	AggregateBuilder,
+	AggregateResult,
+	AggregateSpec,
+	DefaultModelRow,
+	GroupedCollection,
+	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 } from "../relation.js";
+
+type AnyFunction = (...arguments_: ReadonlyArray<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, Requirement> = Method extends (
+	...arguments_: infer Arguments
+) => PromiseLike<infer Value>
+	? (
+			...arguments_: Arguments
+		) => Effect.Effect<Awaited<Value>, PrismaError, Requirement>
+	: never;
+
+type SelectMethod<
+	Collection,
+	Requirement,
+	Contract,
+	Model extends string,
+> = Contract extends AnyPostgresContract
+	? Collection extends PrismaCollection<
+			Contract,
+			Model,
+			infer _Row,
+			infer State
+		>
+		? {
+				select<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
+					...fields: Fields
+				): Relation<
+					PrismaCollection<
+						Contract,
+						Model,
+						Pick<DefaultModelRow<Contract, Model>, Fields[number]>,
+						State
+					>,
+					Requirement,
+					Contract,
+					Model
+				>;
+			}
+		: 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, Requirement, Contract, Model>
+							: never
+					: never;
+			}
+		: Record<never, never>;
+
+type AggregateConfigure<Collection> = Collection extends {
+	aggregate: infer Method extends AnyFunction;
+}
+	? 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>
+				>
+			>
+		: AggregateResult<Spec>;
+
+type AggregateMethod<
+	Collection,
+	Requirement,
+	Contract,
+	Model extends string,
+> = Contract extends AnyPostgresContract
+	? Collection extends { aggregate: AnyFunction }
+		? {
+				aggregate<Spec extends AggregateSpec>(
+					make: (aggregate: AggregateBuilder<Contract, Model>) => Spec,
+					configure?: AggregateConfigure<Collection>,
+				): Effect.Effect<
+					AggregateSuccess<Collection, Contract, Model, Spec>,
+					PrismaError,
+					Requirement
+				>;
+			}
+		: Record<never, never>
+	: Record<never, never>;
+
+type CollectionMethods<
+	Collection,
+	Requirement,
+	Contract,
+	Model extends string,
+> = Contract extends AnyPostgresContract
+	? Collection extends PrismaCollection<
+			Contract,
+			Model,
+			infer _Row,
+			infer State
+		>
+		? {
+				groupBy<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
+					...fields: Fields
+				): Relation<
+					GroupedCollection<Contract, Model, Fields>,
+					Requirement,
+					Contract,
+					Model
+				>;
+				cursor(
+					values: State extends { readonly hasOrderBy: true }
+						? Partial<
+								Record<keyof DefaultModelRow<Contract, Model> & string, unknown>
+							>
+						: never,
+				): Relation<Collection, Requirement, Contract, Model>;
+				distinct<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
+					...fields: Fields
+				): Relation<Collection, Requirement, Contract, Model>;
+				distinctOn<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
+					...fields: State extends { readonly hasOrderBy: true }
+						? Fields
+						: never
+				): Relation<Collection, Requirement, Contract, Model>;
+			} & (State extends { readonly hasWhere: true }
+				? {
+						readonly [Key in
+							| "delete"
+							| "deleteAll"
+							| "deleteCount"]: TerminalMethod<Collection[Key], Requirement>;
+					}
+				: Record<never, never>)
+		: Record<never, never>
+	: Record<never, never>;
+
+type CollectionConveniences<
+	Collection,
+	Requirement,
+	Contract,
+	Model extends string,
+> = Contract extends AnyPostgresContract
+	? Collection extends PrismaCollection<
+			Contract,
+			Model,
+			infer Row,
+			infer _State
+		>
+		? {
+				readonly stream: Stream.Stream<Row, PrismaError, Requirement>;
+				exists(): Effect.Effect<boolean, PrismaError, Requirement>;
+			}
+		: Record<never, never>
+	: CollectionResult<Collection> extends ReadonlyArray<infer Row>
+		? {
+				readonly stream: Stream.Stream<Row, PrismaError, Requirement>;
+				exists(): Effect.Effect<boolean, PrismaError, Requirement>;
+			}
+		: Record<never, never>;
+
+export type PrismaRelationMethods<
+	Collection,
+	Requirement,
+	Contract,
+	Model extends string,
+> = SelectMethod<Collection, Requirement, Contract, Model> &
+	AggregateMethod<Collection, Requirement, Contract, Model> &
+	CollectionMethods<Collection, Requirement, Contract, Model> &
+	CollectionConveniences<Collection, Requirement, Contract, Model>;

package/src/relation.ts

@@ -0,0 +1,104 @@
+import type { Effect } from "effect";
+import type { PrismaError } from "./error.js";
+import type { PrismaRelationMethods } from "./relation/prisma-methods.js";
+
+type AnyFunction = (...arguments_: ReadonlyArray<never>) => unknown;
+
+export type CollectionResult<Collection> = Collection extends {
+	all(): infer Result;
+}
+	? Awaited<Result>
+	: never;
+
+type NormalizeTerminal<Name, Result> = Name extends "first"
+	? import("effect").Option.Option<Exclude<Result, null>>
+	: Result;
+
+type WrapReturn<Name, Result, Requirement, Contract, Model extends string> =
+	Result extends PromiseLike<infer Value>
+		? Effect.Effect<
+				NormalizeTerminal<Name, Awaited<Value>>,
+				PrismaError,
+				Requirement
+			>
+		: Result extends object
+			? Relation<Result, Requirement, Contract, Model>
+			: never;
+
+type WrapFunction<
+	Name,
+	Function_,
+	Requirement,
+	Contract,
+	Model extends string,
+> = Function_ extends {
+	(...arguments_: infer Arguments1): infer Result1;
+	(...arguments_: infer Arguments2): infer Result2;
+	(...arguments_: infer Arguments3): infer Result3;
+	(...arguments_: infer Arguments4): infer Result4;
+	(...arguments_: infer Arguments5): infer Result5;
+	(...arguments_: infer Arguments6): infer Result6;
+}
+	? ((
+			...arguments_: Arguments1
+		) => WrapReturn<Name, Result1, Requirement, Contract, Model>) &
+			((
+				...arguments_: Arguments2
+			) => WrapReturn<Name, Result2, Requirement, Contract, Model>) &
+			((
+				...arguments_: Arguments3
+			) => WrapReturn<Name, Result3, Requirement, Contract, Model>) &
+			((
+				...arguments_: Arguments4
+			) => WrapReturn<Name, Result4, Requirement, Contract, Model>) &
+			((
+				...arguments_: Arguments5
+			) => WrapReturn<Name, Result5, Requirement, Contract, Model>) &
+			((
+				...arguments_: Arguments6
+			) => WrapReturn<Name, Result6, Requirement, Contract, Model>)
+	: never;
+
+type FunctionKeys<Value> = {
+	[Key in keyof Value]-?: Value[Key] extends AnyFunction ? Key : never;
+}[keyof Value];
+
+type ExplicitPrismaMethod =
+	| "aggregate"
+	| "avg"
+	| "combine"
+	| "count"
+	| "cursor"
+	| "delete"
+	| "deleteAll"
+	| "deleteCount"
+	| "distinct"
+	| "distinctOn"
+	| "groupBy"
+	| "include"
+	| "max"
+	| "min"
+	| "select"
+	| "sum"
+	| "variant";
+
+type RelationMethods<
+	Collection,
+	Requirement,
+	Contract,
+	Model extends string,
+> = {
+	readonly [Key in Exclude<
+		FunctionKeys<Collection>,
+		ExplicitPrismaMethod
+	>]: WrapFunction<Key, Collection[Key], Requirement, Contract, Model>;
+};
+
+export type Relation<
+	Collection,
+	Requirement,
+	Contract = undefined,
+	Model extends string = string,
+> = Effect.Effect<CollectionResult<Collection>, PrismaError, Requirement> &
+	RelationMethods<Collection, Requirement, Contract, Model> &
+	PrismaRelationMethods<Collection, Requirement, Contract, Model>;

package/src/testing/transaction.ts

@@ -0,0 +1,28 @@
+import type { Effect } from "effect";
+import type { PrismaError } from "../error.js";
+import { getDatabaseTesting } from "../internal/testing.js";
+import type { AnyDatabase, DatabaseRequirement } from "./types.js";
+
+type WithTestTransaction = {
+	<Database extends AnyDatabase>(
+		database: Database,
+	): <A, E, R>(
+		program: Effect.Effect<A, E, R>,
+	) => Effect.Effect<A, E | PrismaError, R | DatabaseRequirement<Database>>;
+	<Database extends AnyDatabase, A, E, R>(
+		database: Database,
+		program: Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | PrismaError, R | DatabaseRequirement<Database>>;
+};
+
+export const withTestTransaction: WithTestTransaction = ((
+	database: AnyDatabase,
+	program?: Effect.Effect<unknown, unknown, unknown>,
+) => {
+	const run = (effect: Effect.Effect<unknown, unknown, unknown>) =>
+		getDatabaseTesting<DatabaseRequirement<typeof database>>(
+			database,
+		).withTestTransaction(effect);
+
+	return program === undefined ? run : run(program);
+}) as WithTestTransaction;

package/src/testing/types.ts

@@ -0,0 +1,67 @@
+import type { TestContext, TestOptions, Vitest } from "@effect/vitest";
+import type { Contract as PrismaContract } from "@prisma-next/contract/types";
+import type { SqlStorage } from "@prisma-next/sql-contract/types";
+import type { Effect, Layer } from "effect";
+import type { DatabaseDefinition } from "../database.js";
+
+type AnyPostgresContract = PrismaContract<SqlStorage>;
+
+export type AnyDatabase = Effect.Effect<unknown, never, unknown> & {
+	readonly layer: (...arguments_: ReadonlyArray<never>) => Layer.Any;
+};
+
+export type DatabaseRequirement<Database> =
+	Database extends DatabaseDefinition<AnyPostgresContract, infer Requirement>
+		? Requirement
+		: never;
+
+export type DatabaseService<Database extends AnyDatabase> =
+	Effect.Success<Database>;
+
+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>,
+	options?: number | TestOptions,
+) => 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>;
+	readonly each: <Item>(
+		cases: ReadonlyArray<Item>,
+	) => <A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
+		name: string,
+		body: (
+			item: Item,
+			database: DatabaseService<Database>,
+			context: TestContext,
+		) => Generator<Eff, A, never>,
+		options?: number | TestOptions,
+	) => void;
+	readonly fails: DatabaseTest<Database, Provided>;
+}
+
+export type DatabaseIt<
+	Database extends AnyDatabase,
+	Provided,
+> = Vitest.Methods & {
+	readonly effectDB: DatabaseTester<Database, Provided>;
+};
+
+export interface MakeDatabaseItOptions<
+	Database extends AnyDatabase,
+	Provided,
+	LayerError,
+> {
+	readonly database: Database;
+	readonly layer: Layer.Layer<Provided, LayerError>;
+}

package/src/testing/vitest.ts

@@ -0,0 +1,67 @@
+import { it as effectIt } from "@effect/vitest";
+import { Effect, Exit, Layer, Scope } from "effect";
+import {
+	type FixtureTestApi,
+	fixtureName,
+	makeDatabaseTester,
+} from "../internal/vitest-database.js";
+import type {
+	AnyDatabase,
+	DatabaseIt,
+	DatabaseRequirement,
+	MakeDatabaseItOptions,
+} from "./types.js";
+
+export const makeDatabaseIt = <
+	Database extends AnyDatabase,
+	Provided,
+	LayerError,
+>(
+	options: MakeDatabaseItOptions<Database, Provided, LayerError> & {
+		readonly layer: Layer.Layer<
+			Provided | DatabaseRequirement<Database> | Effect.Services<Database>,
+			LayerError
+		>;
+	},
+): DatabaseIt<
+	Database,
+	Provided | DatabaseRequirement<Database> | Effect.Services<Database>
+> => {
+	type Services =
+		| Provided
+		| DatabaseRequirement<Database>
+		| Effect.Services<Database>;
+
+	const fixtureIt = effectIt.extend(
+		fixtureName,
+		{ scope: "worker" },
+		// biome-ignore lint/correctness/noEmptyPattern: Vitest fixtures require a destructured context parameter.
+		async ({}, { onCleanup }) => {
+			const scope = Effect.runSync(Scope.make());
+			onCleanup(() => Effect.runPromise(Scope.close(scope, Exit.void)));
+
+			try {
+				return await Effect.runPromise(
+					Layer.buildWithScope(options.layer, scope),
+				);
+			} catch (error) {
+				await Effect.runPromise(Scope.close(scope, Exit.void));
+				throw error;
+			}
+		},
+	);
+
+	const effectDB = makeDatabaseTester(
+		fixtureIt as unknown as FixtureTestApi<Services>,
+		options.database,
+	);
+
+	return new Proxy(effectIt, {
+		get(target, property, receiver) {
+			if (property === "effectDB") {
+				return effectDB;
+			}
+			return Reflect.get(target, property, receiver);
+		},
+	}) as unknown as DatabaseIt<Database, Services>;
+};

package/src/testing.ts

@@ -0,0 +1,8 @@
+export { withTestTransaction } from "./testing/transaction.js";
+export type {
+	DatabaseIt,
+	DatabaseTest,
+	DatabaseTester,
+	MakeDatabaseItOptions,
+} from "./testing/types.js";
+export { makeDatabaseIt } from "./testing/vitest.js";