@shivaedev/effect-prisma 0.0.0 → 0.2.0

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);
+};

package/src/relation/include-metadata.ts

@@ -0,0 +1,102 @@
+import type { Contract as PrismaContract } from "@prisma-next/contract/types";
+import type { SqlStorage } from "@prisma-next/sql-contract/types";
+import type { RelationsOf } from "@prisma-next/sql-orm-client";
+
+export type AnyPostgresContract = PrismaContract<SqlStorage>;
+
+type RelationDefinition<
+	Contract extends AnyPostgresContract,
+	Model extends string,
+	RelationName extends string,
+> = RelationName extends keyof RelationsOf<Contract, Model>
+	? RelationsOf<Contract, Model>[RelationName]
+	: never;
+
+type RelationCardinalityOf<
+	Contract extends AnyPostgresContract,
+	Model extends string,
+	RelationName extends string,
+> =
+	RelationDefinition<Contract, Model, RelationName> extends {
+		readonly cardinality: infer Cardinality extends string;
+	}
+		? Cardinality
+		: never;
+
+export type IsToManyRelation<
+	Contract extends AnyPostgresContract,
+	Model extends string,
+	RelationName extends string,
+> =
+	RelationCardinalityOf<Contract, Model, RelationName> extends "1:N" | "N:M"
+		? true
+		: false;
+
+export type RelatedModelNameOf<
+	Contract extends AnyPostgresContract,
+	Model extends string,
+	RelationName extends string,
+> =
+	RelationDefinition<Contract, Model, RelationName> extends {
+		readonly to: { readonly model: infer Related extends string };
+	}
+		? Related
+		: never;
+
+type RelationLocalFields<
+	Contract extends AnyPostgresContract,
+	Model extends string,
+	RelationName extends string,
+> =
+	RelationDefinition<Contract, Model, RelationName> extends {
+		readonly on: {
+			readonly localFields: infer Fields extends readonly string[];
+		};
+	}
+		? Fields
+		: readonly [];
+
+type DefaultNamespace<Contract extends AnyPostgresContract> =
+	Contract["domain"]["namespaces"][keyof Contract["domain"]["namespaces"]];
+
+type ModelFields<Contract extends AnyPostgresContract, Model extends string> =
+	DefaultNamespace<Contract> extends {
+		readonly models: infer Models;
+	}
+		? Model extends keyof Models
+			? Models[Model] extends { readonly fields: infer Fields }
+				? Fields
+				: never
+			: never
+		: never;
+
+type AnyNullableField<
+	Fields,
+	Names extends readonly string[],
+> = Names extends readonly [
+	infer Head extends string,
+	...infer Tail extends readonly string[],
+]
+	? Head extends keyof Fields
+		? Fields[Head] extends { readonly nullable: true }
+			? true
+			: AnyNullableField<Fields, Tail>
+		: true
+	: false;
+
+export type IncludedRelationValue<
+	Contract extends AnyPostgresContract,
+	Model extends string,
+	RelationName extends string,
+	Value,
+> =
+	RelationCardinalityOf<Contract, Model, RelationName> extends "1:N" | "N:M"
+		? Array<Value>
+		: RelationCardinalityOf<Contract, Model, RelationName> extends "N:1"
+			? AnyNullableField<
+					ModelFields<Contract, Model>,
+					RelationLocalFields<Contract, Model, RelationName>
+				> extends true
+				? Value | null
+				: Value
+			: Value | null;

package/src/relation/include.ts

@@ -0,0 +1,169 @@
+import type {
+	DefaultModelRow,
+	Collection as PrismaCollection,
+	RelationNames,
+} from "@prisma-next/sql-orm-client";
+import type { Relation, RelationQuery } from "../relation.js";
+import type {
+	AnyPostgresContract,
+	IncludedRelationValue,
+	IsToManyRelation,
+	RelatedModelNameOf,
+} from "./include-metadata.js";
+
+type Simplify<Value> = { [Key in keyof Value]: Value[Key] };
+
+type QueryValue<Query> =
+	Query extends RelationQuery<
+		infer Value,
+		infer _Requirement,
+		infer _Contract,
+		infer _Model
+	>
+		? Value
+		: never;
+
+type AcceptRelatedQuery<
+	Query,
+	Contract extends AnyPostgresContract,
+	Model extends string,
+> =
+	Query extends RelationQuery<
+		infer _Value,
+		infer _Requirement,
+		infer QueryContract,
+		infer QueryModel
+	>
+		? [QueryContract] extends [Contract]
+			? [Contract] extends [QueryContract]
+				? QueryModel extends Model
+					? unknown
+					: never
+				: never
+			: never
+		: never;
+
+type IncludedQueryValue<
+	Query,
+	Contract extends AnyPostgresContract,
+	Model extends string,
+	RelationName extends string,
+> =
+	QueryValue<Query> extends ReadonlyArray<infer Row>
+		? IncludedRelationValue<Contract, Model, RelationName, Row>
+		: QueryValue<Query>;
+
+type QueryShapeValue<Shape extends Readonly<Record<string, unknown>>> = {
+	readonly [Key in keyof Shape]: QueryValue<Shape[Key]>;
+};
+
+type AcceptRelatedQueryShape<
+	Shape extends Readonly<Record<string, unknown>>,
+	Contract extends AnyPostgresContract,
+	Model extends string,
+> = {
+	readonly [Key in keyof Shape]: Shape[Key] &
+		AcceptRelatedQuery<Shape[Key], Contract, Model>;
+};
+
+type WithIncludedRelation<
+	Collection,
+	Contract extends AnyPostgresContract,
+	Model extends string,
+	RelationName extends string,
+	Value,
+> =
+	Collection extends PrismaCollection<Contract, Model, infer Row, infer State>
+		? PrismaCollection<
+				Contract,
+				Model,
+				Simplify<Row & { readonly [Key in RelationName]: Value }>,
+				State
+			>
+		: never;
+
+export type IncludeMethod<
+	Collection,
+	Requirement,
+	Contract,
+	Model extends string,
+> = 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>
+							>
+						>
+					>,
+					Requirement,
+					Contract,
+					Model
+				>;
+				include<RelationName extends RelationNames<Contract, Model>, Query>(
+					relationName: RelationName,
+					query: Query &
+						AcceptRelatedQuery<
+							Query,
+							Contract,
+							RelatedModelNameOf<Contract, Model, RelationName>
+						>,
+				): Relation<
+					WithIncludedRelation<
+						Collection,
+						Contract,
+						Model,
+						RelationName,
+						IncludedQueryValue<Query, Contract, Model, RelationName>
+					>,
+					Requirement,
+					Contract,
+					Model
+				>;
+				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>
+									>
+						: never,
+				): Relation<
+					WithIncludedRelation<
+						Collection,
+						Contract,
+						Model,
+						RelationName,
+						QueryShapeValue<Shape>
+					>,
+					Requirement,
+					Contract,
+					Model
+				>;
+			}
+		: Record<never, never>
+	: Record<never, never>;