@shivaedev/effect-prisma 0.6.3 → 0.7.0

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,17 +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,9 +1,7 @@
 import type { Effect } from "effect";
-import type { PrismaError } from "../error.js";
+import type { PrismaError } from "../error.ts";
 
-export const DatabaseTestingTypeId: unique symbol = Symbol.for(
-	"@shivaedev/effect-prisma/DatabaseTesting",
-);
+export const DatabaseTestingTypeId: unique symbol = Symbol.for("@shivaedev/effect-prisma/DatabaseTesting");
 
 export interface DatabaseTesting<DatabaseId> {
 	readonly withTestTransaction: <A, E, R>(
@@ -15,18 +13,18 @@ export interface DatabaseWithTesting<DatabaseId> {
 	readonly [DatabaseTestingTypeId]: DatabaseTesting<DatabaseId>;
 }
 
-export const getDatabaseTesting = <DatabaseId>(
-	database: object,
-): DatabaseTesting<DatabaseId> => {
-	const testing = Reflect.get(database, DatabaseTestingTypeId) as
-		| DatabaseTesting<DatabaseId>
-		| undefined;
+// makeSqlDatabase installs the testing hooks for the database's own service identifier.
+function testingFor<DatabaseId>(testing: object): DatabaseTesting<DatabaseId>;
+function testingFor(testing: object): unknown {
+	return testing;
+}
 
-	if (testing === undefined) {
-		throw new TypeError(
-			"The database was not created by this copy of @shivaedev/effect-prisma",
-		);
+export const getDatabaseTesting = <DatabaseId>(database: object): DatabaseTesting<DatabaseId> => {
+	const testing: unknown = Reflect.get(database, DatabaseTestingTypeId);
+
+	if (typeof testing !== "object" || testing === null || typeof Reflect.get(testing, "withTestTransaction") !== "function") {
+		throw new TypeError("The database was not created by this copy of @shivaedev/effect-prisma");
 	}
 
-	return testing;
+	return testingFor<DatabaseId>(testing);
 };

package/src/internal/transaction.ts

@@ -1,45 +1,26 @@
 import { orm } from "@prisma-next/sql-orm-client";
-import type {
-	RuntimeConnection,
-	RuntimeTransaction,
-} from "@prisma-next/sql-runtime";
 import { Effect, Exit, Semaphore } from "effect";
-import type { PrismaError } from "../error.js";
-import type { AnySqlContract, DatabaseExecutor } from "./executor.js";
-import { fromPrismaPromise } from "./promise.js";
+import type { PrismaError } from "../error.ts";
+import { type SettledConnection, type SettledTransaction, settleConnection } from "./adapters/transaction-settlement.ts";
+import type { AnySqlContract, DatabaseExecutor } from "./executor.ts";
+import { fromPrismaPromise } from "./promise.ts";
 
-export type TransactionOrm<Contract extends AnySqlContract> = ReturnType<
-	typeof orm<Contract>
->;
+export type TransactionOrm<Contract extends AnySqlContract> = ReturnType<typeof orm<Contract>>;
 
 export const withTransactionSemaphore = <A, E, R>(
 	semaphore: Semaphore.Semaphore | undefined,
 	transaction: Effect.Effect<A, E, R>,
-): Effect.Effect<A, E, R> =>
-	semaphore === undefined ? transaction : semaphore.withPermit(transaction);
+): Effect.Effect<A, E, R> => (semaphore === undefined ? transaction : semaphore.withPermit(transaction));
 
-export interface TransactionResource<
-	Models extends object,
-	Contract extends AnySqlContract,
-> {
-	readonly connection: RuntimeConnection;
-	readonly transaction: RuntimeTransaction;
+export interface TransactionResource<Models extends object, Contract extends AnySqlContract> {
+	readonly connection: SettledConnection;
 	readonly executor: DatabaseExecutor<Models, Contract> & {
 		readonly querySemaphore: Semaphore.Semaphore;
 	};
+	readonly transaction: SettledTransaction;
 }
 
-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 AnySqlContract,
->(
+export const acquireTransaction = <Models extends object, Contract extends AnySqlContract>(
 	current: DatabaseExecutor<Models, Contract>,
 	models: (orm: TransactionOrm<Contract>) => Models,
 	mode: "test" | "transaction",
@@ -50,13 +31,12 @@ export const acquireTransaction = <
 		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,
@@ -70,6 +50,7 @@ export const acquireTransaction = <
 					transactionIdentity: {},
 					transactionSemaphore: current.transactionSemaphore,
 				},
+				transaction,
 			};
 		} catch (error) {
 			await connection.destroy(error).catch(() => undefined);
@@ -77,32 +58,17 @@ export const acquireTransaction = <
 		}
 	});
 
-export const releaseTransaction = <
-	Models extends object,
-	Contract extends AnySqlContract,
-	A,
-	E,
->(
+export const releaseTransaction = <Models extends object, Contract extends AnySqlContract, 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 AnySqlContract,
-	A,
-	E,
->(
+export const releaseTestTransaction = <Models extends object, Contract extends AnySqlContract, 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 AnySqlContract,
-	A,
-	E,
->(
+const settleTransaction = <Models extends object, Contract extends AnySqlContract, A, E>(
 	resource: TransactionResource<Models, Contract>,
 	exit: Exit.Exit<A, E>,
 	commitOnSuccess: boolean,
@@ -112,66 +78,7 @@ const settleTransaction = <
 			resource.executor.liveness.open = false;
 		}).pipe(
 			Effect.andThen(
-				resource.executor.querySemaphore.withPermit(
-					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;
-						}
-					}),
-				),
+				resource.executor.querySemaphore.withPermit(fromPrismaPromise(() => settleConnection(resource, commitOnSuccess && Exit.isSuccess(exit)))),
 			),
 		),
 	);

package/src/relation/include-metadata.ts

@@ -8,46 +8,26 @@ type RelationDefinition<
 	Contract extends AnyPostgresContract,
 	Model extends string,
 	RelationName extends string,
-> = RelationName extends keyof RelationsOf<Contract, Model>
-	? RelationsOf<Contract, Model>[RelationName]
-	: never;
+> = RelationName extends keyof RelationsOf<Contract, Model> ? RelationsOf<Contract, Model>[RelationName] : never;
 
-type RelationCardinalityOf<
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	RelationName extends string,
-> =
+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 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,
-> =
+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,
-> =
+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[];
@@ -56,8 +36,7 @@ type RelationLocalFields<
 		? Fields
 		: readonly [];
 
-type DefaultNamespace<Contract extends AnyPostgresContract> =
-	Contract["domain"]["namespaces"][keyof Contract["domain"]["namespaces"]];
+type DefaultNamespace<Contract extends AnyPostgresContract> = Contract["domain"]["namespaces"][keyof Contract["domain"]["namespaces"]];
 
 type ModelFields<Contract extends AnyPostgresContract, Model extends string> =
 	DefaultNamespace<Contract> extends {
@@ -70,10 +49,7 @@ type ModelFields<Contract extends AnyPostgresContract, Model extends string> =
 			: never
 		: never;
 
-type AnyNullableField<
-	Fields,
-	Names extends readonly string[],
-> = Names extends readonly [
+type AnyNullableField<Fields, Names extends readonly string[]> = Names extends readonly [
 	infer Head extends string,
 	...infer Tail extends readonly string[],
 ]
@@ -84,19 +60,11 @@ type AnyNullableField<
 		: true
 	: false;
 
-export type IncludedRelationValue<
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	RelationName extends string,
-	Value,
-> =
+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
+			? AnyNullableField<ModelFields<Contract, Model>, RelationLocalFields<Contract, Model, RelationName>> extends true
 				? Value | null
 				: Value
 			: Value | null;

package/src/relation/include.ts

@@ -1,40 +1,13 @@
-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";
+import type { DefaultModelRow, Collection as PrismaCollection, RelationNames } from "@prisma-next/sql-orm-client";
+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] };
 
-type QueryValue<Query> =
-	Query extends RelationQuery<
-		infer Value,
-		infer _Contract,
-		infer _Model,
-		infer _DatabaseId
-	>
-		? Value
-		: never;
+type QueryValue<Query> = Query extends RelationQuery<infer Value, infer _Contract, infer _Model, infer _DatabaseId> ? Value : never;
 
-type AcceptRelatedQuery<
-	Query,
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	DatabaseId,
-> = [Query] extends [
-	RelationQuery<
-		infer _Value,
-		infer QueryContract,
-		infer QueryModel,
-		infer QueryDatabaseId
-	>,
+type AcceptRelatedQuery<Query, Contract extends AnyPostgresContract, Model extends string, DatabaseId> = [Query] extends [
+	RelationQuery<infer _Value, infer QueryContract, infer QueryModel, infer QueryDatabaseId>,
 ]
 	? [QueryContract] extends [Contract]
 		? [Contract] extends [QueryContract]
@@ -49,15 +22,8 @@ type AcceptRelatedQuery<
 		: 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 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]>;
@@ -69,110 +35,50 @@ type AcceptRelatedQueryShape<
 	Model extends string,
 	DatabaseId,
 > = {
-	readonly [Key in keyof Shape]: Shape[Key] &
-		AcceptRelatedQuery<Shape[Key], Contract, Model, DatabaseId>;
+	readonly [Key in keyof Shape]: Shape[Key] & AcceptRelatedQuery<Shape[Key], Contract, Model, DatabaseId>;
 };
 
-type WithIncludedRelation<
-	Collection,
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	RelationName extends string,
-	Value,
-> =
+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
-			>
+		? PrismaCollection<Contract, Model, Simplify<Row & { readonly [Key in RelationName]: Value }>, State>
 		: never;
 
-export type IncludeMethod<
-	Collection,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = Contract extends AnyPostgresContract
-	? Collection extends PrismaCollection<
+interface IncludeOverloads<Collection, Contract extends AnyPostgresContract, Model extends string, DatabaseId> {
+	<RelationName extends RelationNames<Contract, Model>>(
+		relationName: RelationName,
+	): Relation<
+		WithIncludedRelation<
+			Collection,
 			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
-				>;
-			}
+			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: IncludeOverloads<Collection, Contract, Model, DatabaseId> }
 		: Record<never, never>
 	: Record<never, never>;