@shivaedev/effect-prisma 0.0.0 → 0.1.0

package/src/internal/relation-runtime.ts

@@ -0,0 +1,217 @@
+import type { Context } from "effect";
+import { Effect, Effectable, Option, Stream } from "effect";
+import { isPrismaFailure, type PrismaError, toPrismaError } from "../error.js";
+import type { Relation } from "../relation.js";
+import type {
+	AnyPostgresContract,
+	DatabaseExecutor,
+	ExecutorIdentifier,
+} from "./executor.js";
+import { fromPrismaPromise } from "./promise.js";
+import {
+	appendOperation,
+	type RelationRecipe,
+	replayRecipe,
+	rootRecipe,
+} from "./recipe.js";
+
+type AnyFunction = (...arguments_: ReadonlyArray<never>) => unknown;
+
+interface RelationRuntime<
+	Models extends object,
+	Contract extends AnyPostgresContract,
+> {
+	readonly executor: Context.Service<
+		ExecutorIdentifier<Models>,
+		DatabaseExecutor<Models, Contract>
+	>;
+	readonly recipe: RelationRecipe;
+	readonly terminal?: PropertyKey;
+}
+
+const evaluateResult = (
+	value: unknown,
+	terminal: PropertyKey | undefined,
+): Effect.Effect<unknown, PrismaError> => {
+	if (
+		terminal === "exists" &&
+		typeof value === "object" &&
+		value !== null &&
+		typeof Reflect.get(value, "first") === "function"
+	) {
+		const first = Reflect.apply(
+			Reflect.get(value, "first") as AnyFunction,
+			value,
+			[],
+		);
+		return fromPrismaPromise(() => first as PromiseLike<unknown>).pipe(
+			Effect.map((result) => result !== null),
+		);
+	}
+
+	const executable =
+		typeof value === "object" &&
+		value !== null &&
+		typeof Reflect.get(value, "all") === "function"
+			? Reflect.apply(Reflect.get(value, "all") as AnyFunction, value, [])
+			: value;
+
+	if (
+		typeof executable === "object" &&
+		executable !== null &&
+		"then" in executable
+	) {
+		return fromPrismaPromise(() => executable as PromiseLike<unknown>).pipe(
+			Effect.map((result) =>
+				terminal === "first" ? Option.fromNullishOr(result) : result,
+			),
+		);
+	}
+
+	return Effect.succeed(executable);
+};
+
+interface RelationValue<
+	Models extends object,
+	Contract extends AnyPostgresContract,
+> extends Effect.Effect<unknown, PrismaError, ExecutorIdentifier<Models>> {
+	readonly runtime: RelationRuntime<Models, Contract>;
+	readonly stream: Stream.Stream<
+		unknown,
+		PrismaError,
+		ExecutorIdentifier<Models>
+	>;
+}
+
+const relationEffect = <
+	Models extends object,
+	Contract extends AnyPostgresContract,
+>(
+	self: RelationValue<Models, Contract>,
+): Effect.Effect<unknown, PrismaError, ExecutorIdentifier<Models>> =>
+	Effect.flatMap(self.runtime.executor, (executor) =>
+		Effect.suspend(() =>
+			evaluateResult(
+				replayRecipe(executor.models, self.runtime.recipe),
+				self.runtime.terminal,
+			),
+		),
+	).pipe(
+		Effect.withSpan(
+			`prisma.${self.runtime.recipe.model}.${String(self.runtime.terminal ?? "all")}`,
+			{
+				kind: "client",
+				attributes: {
+					"db.system": "postgresql",
+					"db.model": self.runtime.recipe.model,
+					"db.operation": String(self.runtime.terminal ?? "all"),
+				},
+			},
+		),
+	);
+
+const relationStream = <
+	Models extends object,
+	Contract extends AnyPostgresContract,
+>(
+	self: RelationValue<Models, Contract>,
+): Stream.Stream<unknown, PrismaError, ExecutorIdentifier<Models>> => {
+	const result = Effect.map(self.runtime.executor, (executor) => {
+		const collection = replayRecipe(executor.models, self.runtime.recipe);
+		if (
+			typeof collection !== "object" ||
+			collection === null ||
+			typeof Reflect.get(collection, "all") !== "function"
+		) {
+			throw new TypeError("Only collection Relations can be streamed");
+		}
+		return Reflect.apply(
+			Reflect.get(collection, "all") as AnyFunction,
+			collection,
+			[],
+		) as AsyncIterable<unknown>;
+	});
+
+	return Stream.unwrap(
+		Effect.map(result, (iterable) =>
+			Stream.fromAsyncIterable(iterable, (error) => error).pipe(
+				Stream.catch((error) =>
+					isPrismaFailure(error)
+						? Stream.fail(toPrismaError(error))
+						: Stream.die(error),
+				),
+			),
+		),
+	);
+};
+
+const RelationPrototype = {
+	...Effectable.Prototype<
+		RelationValue<Record<string, unknown>, AnyPostgresContract>
+	>({
+		label: "EffectPrismaRelation",
+		evaluate() {
+			return relationEffect(this);
+		},
+	}),
+	get stream(): Stream.Stream<
+		unknown,
+		PrismaError,
+		ExecutorIdentifier<Record<string, unknown>>
+	> {
+		return relationStream(
+			this as RelationValue<Record<string, unknown>, AnyPostgresContract>,
+		);
+	},
+};
+
+const makeRelationProxy = <
+	Models extends object,
+	Contract extends AnyPostgresContract,
+>(
+	runtime: RelationRuntime<Models, Contract>,
+): unknown => {
+	const target = Object.assign(Object.create(RelationPrototype), {
+		runtime,
+	}) as RelationValue<Models, Contract>;
+
+	return new Proxy(target, {
+		get(self, property, receiver) {
+			if (property === "then") {
+				return undefined;
+			}
+			if (Reflect.has(self, property)) {
+				return Reflect.get(self, property, receiver);
+			}
+			if (property === "exists") {
+				return () =>
+					makeRelationProxy({
+						...runtime,
+						terminal: "exists",
+					});
+			}
+			return (...arguments_: ReadonlyArray<unknown>) =>
+				makeRelationProxy({
+					...runtime,
+					recipe: appendOperation(runtime.recipe, property, arguments_),
+					terminal: property,
+				});
+		},
+	});
+};
+
+export const makeModelRelation = <
+	Collection,
+	Models extends object,
+	Contract extends AnyPostgresContract = AnyPostgresContract,
+>(
+	executor: Context.Service<
+		ExecutorIdentifier<Models>,
+		DatabaseExecutor<Models, Contract>
+	>,
+	model: string,
+): Relation<Collection, ExecutorIdentifier<Models>> =>
+	makeRelationProxy({
+		executor,
+		recipe: rootRecipe(model),
+	}) as Relation<Collection, ExecutorIdentifier<Models>>;

package/src/internal/testing.ts

@@ -0,0 +1,32 @@
+import type { Effect } from "effect";
+import type { PrismaError } from "../error.js";
+
+export const DatabaseTestingTypeId: unique symbol = Symbol.for(
+	"@shivaedev/effect-prisma/DatabaseTesting",
+);
+
+export interface DatabaseTesting<Requirement> {
+	readonly withTestTransaction: <A, E, R>(
+		program: Effect.Effect<A, E, R>,
+	) => Effect.Effect<A, E | PrismaError, R | Requirement>;
+}
+
+export interface DatabaseWithTesting<Requirement> {
+	readonly [DatabaseTestingTypeId]: DatabaseTesting<Requirement>;
+}
+
+export const getDatabaseTesting = <Requirement>(
+	database: object,
+): DatabaseTesting<Requirement> => {
+	const testing = Reflect.get(database, DatabaseTestingTypeId) as
+		| DatabaseTesting<Requirement>
+		| undefined;
+
+	if (testing === undefined) {
+		throw new TypeError(
+			"The database was not created by this copy of @shivaedev/effect-prisma",
+		);
+	}
+
+	return testing;
+};

package/src/internal/transaction.ts

@@ -0,0 +1,149 @@
+import type { PostgresClient } from "@prisma-next/postgres/runtime";
+import { orm } from "@prisma-next/sql-orm-client";
+import type {
+	RuntimeConnection,
+	RuntimeTransaction,
+} from "@prisma-next/sql-runtime";
+import { Effect, Exit } from "effect";
+import type { PrismaError } from "../error.js";
+import type { AnyPostgresContract, DatabaseExecutor } from "./executor.js";
+import { fromPrismaPromise } from "./promise.js";
+
+export interface TransactionResource<
+	Models extends object,
+	Contract extends AnyPostgresContract,
+> {
+	readonly connection: RuntimeConnection;
+	readonly transaction: RuntimeTransaction;
+	readonly executor: DatabaseExecutor<Models, Contract>;
+}
+
+const runtimeFailure = (
+	code: string,
+	cause: unknown,
+	details?: Readonly<Record<string, unknown>>,
+): Error & { readonly code: string } =>
+	Object.assign(new Error(code, { cause }), { code, ...details });
+
+export const acquireTransaction = <
+	Models extends object,
+	Contract extends AnyPostgresContract,
+>(
+	current: DatabaseExecutor<Models, Contract>,
+	models: (orm: PostgresClient<Contract>["orm"]) => Models,
+): Effect.Effect<TransactionResource<Models, Contract>, PrismaError> =>
+	fromPrismaPromise(async () => {
+		const connection = await current.client.runtime().connection();
+
+		try {
+			const transaction = await connection.transaction();
+			const transactionOrm = orm({
+				runtime: transaction,
+				context: current.client.context,
+			});
+
+			return {
+				connection,
+				transaction,
+				executor: {
+					client: current.client,
+					models: models(transactionOrm),
+					transactional: true,
+				},
+			};
+		} catch (error) {
+			await connection.destroy(error).catch(() => undefined);
+			throw error;
+		}
+	});
+
+export const releaseTransaction = <
+	Models extends object,
+	Contract extends AnyPostgresContract,
+	A,
+	E,
+>(
+	resource: TransactionResource<Models, Contract>,
+	exit: Exit.Exit<A, E>,
+): Effect.Effect<void, PrismaError> => settleTransaction(resource, exit, true);
+
+export const releaseTestTransaction = <
+	Models extends object,
+	Contract extends AnyPostgresContract,
+	A,
+	E,
+>(
+	resource: TransactionResource<Models, Contract>,
+	exit: Exit.Exit<A, E>,
+): Effect.Effect<void, PrismaError> => settleTransaction(resource, exit, false);
+
+const settleTransaction = <
+	Models extends object,
+	Contract extends AnyPostgresContract,
+	A,
+	E,
+>(
+	resource: TransactionResource<Models, Contract>,
+	exit: Exit.Exit<A, E>,
+	commitOnSuccess: boolean,
+): Effect.Effect<void, PrismaError> =>
+	Effect.uninterruptible(
+		fromPrismaPromise(async () => {
+			let disposed = false;
+			let failure: unknown;
+
+			const destroy = async (reason: unknown): Promise<void> => {
+				if (disposed) {
+					return;
+				}
+				disposed = true;
+				await resource.connection.destroy(reason).catch(() => undefined);
+			};
+
+			if (commitOnSuccess && Exit.isSuccess(exit)) {
+				try {
+					await resource.transaction.commit();
+				} catch (commitError) {
+					try {
+						await resource.transaction.rollback();
+					} catch {
+						await destroy(commitError);
+					}
+					failure = runtimeFailure(
+						"RUNTIME.TRANSACTION_COMMIT_FAILED",
+						commitError,
+					);
+				}
+			} else {
+				try {
+					await resource.transaction.rollback();
+				} catch (rollbackError) {
+					await destroy(rollbackError);
+					failure = runtimeFailure(
+						"RUNTIME.TRANSACTION_ROLLBACK_FAILED",
+						rollbackError,
+					);
+				}
+			}
+
+			if (!disposed) {
+				try {
+					await resource.connection.release();
+				} catch (releaseError) {
+					await destroy(releaseError);
+					if (failure !== undefined) {
+						throw runtimeFailure(
+							"RUNTIME.TRANSACTION_RELEASE_FAILED",
+							failure,
+							{ releaseError },
+						);
+					}
+					throw releaseError;
+				}
+			}
+
+			if (failure !== undefined) {
+				throw failure;
+			}
+		}),
+	);

package/src/internal/vitest-database.ts

@@ -0,0 +1,210 @@
+import type { TestContext, TestOptions } from "@effect/vitest";
+import { Cause, type Context, Effect, Exit, Layer, type Scope } from "effect";
+import * as TestClock from "effect/testing/TestClock";
+import * as TestConsole from "effect/testing/TestConsole";
+import { withTestTransaction } from "../testing/transaction.js";
+import type {
+	AnyDatabase,
+	DatabaseRequirement,
+	DatabaseService,
+	DatabaseTest,
+	DatabaseTester,
+} from "../testing/types.js";
+
+export const fixtureName = "__effectPrismaContext";
+
+export type DatabaseFixture<Provided> = TestContext & {
+	readonly [fixtureName]: Context.Context<Provided>;
+};
+
+export interface FixtureTestApi<Provided> {
+	(
+		name: string,
+		options: TestOptions,
+		body: (context: DatabaseFixture<Provided>) => Promise<unknown>,
+	): void;
+	readonly skip: FixtureTestApi<Provided>;
+	readonly skipIf: (condition: unknown) => FixtureTestApi<Provided>;
+	readonly runIf: (condition: unknown) => FixtureTestApi<Provided>;
+	readonly only: FixtureTestApi<Provided>;
+	readonly fails: FixtureTestApi<Provided>;
+	readonly for: <Item>(
+		cases: ReadonlyArray<Item>,
+	) => (
+		name: string,
+		options: TestOptions,
+		body: (item: Item, context: DatabaseFixture<Provided>) => Promise<unknown>,
+	) => void;
+}
+
+const TestEnvironment = Layer.mergeAll(TestConsole.layer, TestClock.layer());
+
+const contextFrom = <Provided>(
+	context: TestContext,
+): Context.Context<Provided> =>
+	(context as DatabaseFixture<Provided>)[fixtureName];
+
+const runEffectTest = <A, E>(
+	effect: Effect.Effect<A, E, Scope.Scope>,
+	context: TestContext,
+): Promise<A> =>
+	Effect.runPromise(
+		Effect.gen(function* () {
+			const exit = yield* Effect.exit(effect);
+			if (Exit.isFailure(exit)) {
+				for (const error of Cause.prettyErrors(exit.cause)) {
+					yield* Effect.logError(error);
+				}
+			}
+			return yield* exit;
+		}).pipe(Effect.scoped, Effect.provide(TestEnvironment)),
+		{ signal: context.signal },
+	);
+
+const normalizeTestOptions = (
+	options: number | TestOptions | undefined,
+): TestOptions =>
+	typeof options === "number" ? { timeout: options } : (options ?? {});
+
+const restoreContext = <Provided>(
+	fixture: Context.Context<Provided>,
+	context: Omit<DatabaseFixture<Provided>, typeof fixtureName>,
+): DatabaseFixture<Provided> =>
+	({
+		...context,
+		[fixtureName]: fixture,
+	}) as DatabaseFixture<Provided>;
+
+export const makeDatabaseTester = <Database extends AnyDatabase, Provided>(
+	fixtureIt: FixtureTestApi<
+		Provided | DatabaseRequirement<Database> | Effect.Services<Database>
+	>,
+	database: Database,
+): DatabaseTester<
+	Database,
+	Provided | DatabaseRequirement<Database> | Effect.Services<Database>
+> => {
+	type Services =
+		| Provided
+		| DatabaseRequirement<Database>
+		| Effect.Services<Database>;
+
+	const run = <A, Eff extends Effect.Effect<unknown, unknown, Services>>(
+		body: (
+			database: DatabaseService<Database>,
+			context: TestContext,
+		) => Generator<Eff, A, never>,
+		context: TestContext,
+	): Effect.Effect<A, unknown, Scope.Scope> => {
+		const effect = withTestTransaction(
+			database,
+			Effect.gen(function* () {
+				const service = yield* database as unknown as Effect.Effect<
+					DatabaseService<Database>,
+					never,
+					Effect.Services<Database>
+				>;
+				return yield* Effect.gen(() => body(service, context));
+			}),
+		).pipe(Effect.provide(contextFrom<Services>(context)));
+
+		// The callback constraint proves that its services are in the built
+		// Layer. TypeScript cannot reduce that generic Exclude after
+		// Effect.provide, so the runner closes the type at this private boundary.
+		return effect as unknown as Effect.Effect<A, unknown, Scope.Scope>;
+	};
+
+	const register =
+		(current: FixtureTestApi<Services>): DatabaseTest<Database, Services> =>
+		(name, body, options) =>
+			current(
+				name,
+				normalizeTestOptions(options),
+				({
+					__effectPrismaContext,
+					task,
+					signal,
+					onTestFailed,
+					onTestFinished,
+					skip,
+					annotate,
+					expect,
+					_local,
+				}: DatabaseFixture<Services>) => {
+					const testContext = restoreContext(__effectPrismaContext, {
+						task,
+						signal,
+						onTestFailed,
+						onTestFinished,
+						skip,
+						annotate,
+						expect,
+						_local,
+					});
+					return runEffectTest(run(body, testContext), testContext);
+				},
+			);
+
+	const make = (
+		current: FixtureTestApi<Services>,
+	): DatabaseTester<Database, Services> => {
+		const test = register(current);
+
+		return Object.assign(test, {
+			skip: register(current.skip),
+			skipIf: (condition: unknown) => register(current.skipIf(condition)),
+			runIf: (condition: unknown) => register(current.runIf(condition)),
+			only: register(current.only),
+			each: <Item>(cases: ReadonlyArray<Item>) => {
+				return <A, Eff extends Effect.Effect<unknown, unknown, Services>>(
+					name: string,
+					body: (
+						item: Item,
+						database: DatabaseService<Database>,
+						context: TestContext,
+					) => Generator<Eff, A, never>,
+					options?: number | TestOptions,
+				) =>
+					fixtureIt.for(cases)(
+						name,
+						normalizeTestOptions(options),
+						(
+							item,
+							{
+								__effectPrismaContext,
+								task,
+								signal,
+								onTestFailed,
+								onTestFinished,
+								skip,
+								annotate,
+								expect,
+								_local,
+							}: DatabaseFixture<Services>,
+						) => {
+							const testContext = restoreContext(__effectPrismaContext, {
+								task,
+								signal,
+								onTestFailed,
+								onTestFinished,
+								skip,
+								annotate,
+								expect,
+								_local,
+							});
+							return runEffectTest(
+								run(
+									(service, testContext) => body(item, service, testContext),
+									testContext,
+								),
+								testContext,
+							);
+						},
+					);
+			},
+			fails: register(current.fails),
+		});
+	};
+
+	return make(fixtureIt);
+};