@shivaedev/effect-prisma 0.6.3 → 0.6.4

package/src/database.ts

@@ -1,26 +1,18 @@
-import postgres, {
-	type PostgresClient,
-	type PostgresOptionsBase,
-} from "@prisma-next/postgres/runtime";
+import postgres, { type PostgresClient, type PostgresOptionsBase } from "@prisma-next/postgres/runtime";
 import { type Layer, Redacted } from "effect";
-import type { PrismaError } from "./error.js";
-import { acquireConnectedClient } from "./internal/client-lifecycle.js";
-import {
-	type DatabaseIdentifier,
-	type DatabaseIdentifierLiteral,
-	type DatabaseServiceHolder,
-	type DefaultModels,
-	makeSqlDatabase,
-	namespaceModels,
-} from "./internal/database-factory.js";
-import type { AnySqlContract } from "./internal/executor.js";
-import { fromPrismaPromise } from "./internal/promise.js";
+import type { PrismaError } from "./error.ts";
+import { acquireConnectedClient } from "./internal/client-lifecycle.ts";
+import { namespaceModels } 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";
 
 export type {
 	AnyDatabase,
 	DatabaseService,
 	DatabaseServiceOf,
-} from "./internal/database-factory.js";
+} from "./internal/database-types.ts";
 
 export interface DatabaseLayerOptions extends PostgresOptionsBase {
 	readonly url: string | Redacted.Redacted<string>;
@@ -36,18 +28,20 @@ type DatabaseFactoryOptions<Contract extends AnySqlContract> =
 			readonly contract?: never;
 	  };
 
-export interface DatabaseDefinition<
-	Contract extends AnySqlContract,
-	Identifier extends string,
-> extends DatabaseServiceHolder<Contract, Identifier> {
-	readonly layer: (
-		options: DatabaseLayerOptions,
-	) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
+export interface DatabaseDefinition<Contract extends AnySqlContract, Identifier extends string> extends DatabaseServiceHolder<Contract, Identifier> {
+	readonly layer: (options: DatabaseLayerOptions) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
 }
 
-const defaultModels = <Contract extends AnySqlContract, Models extends object>(
-	client: Pick<PostgresClient<Contract>, "contract" | "orm">,
-): Models => namespaceModels<Contract, Models>(client.contract, client.orm);
+const clientOptions = ({ url, extensions, middleware, poolOptions, verifyMarker }: DatabaseLayerOptions) => ({
+	url: typeof url === "string" ? url : Redacted.value(url),
+	...(extensions === undefined ? {} : { extensions }),
+	...(middleware === undefined ? {} : { middleware }),
+	...(poolOptions === undefined ? {} : { poolOptions }),
+	...(verifyMarker === undefined ? {} : { verifyMarker }),
+});
+
+const defaultModels = <Contract extends AnySqlContract, Models extends object>(client: Pick<PostgresClient<Contract>, "contract" | "orm">): Models =>
+	namespaceModels<Contract, Models>(client.contract, client.orm);
 
 export const makeDatabase =
 	<const Contract extends AnySqlContract>() =>
@@ -57,45 +51,33 @@ export const makeDatabase =
 	): DatabaseDefinition<Contract, Identifier> => {
 		type Models = DefaultModels<Contract>;
 
-		return makeSqlDatabase<Contract, Identifier, DatabaseLayerOptions>(
-			identifier,
-			(layerOptions) => {
-				const clientOptions = {
-					url:
-						typeof layerOptions.url === "string"
-							? layerOptions.url
-							: Redacted.value(layerOptions.url),
-					extensions: layerOptions.extensions,
-					middleware: layerOptions.middleware,
-					poolOptions: layerOptions.poolOptions,
-					verifyMarker: layerOptions.verifyMarker,
-				};
-				const client =
-					options.contract === undefined
-						? postgres<Contract>({
-								...clientOptions,
-								contractJson: options.contractJson,
-							})
-						: postgres<Contract>({
-								...clientOptions,
-								contract: options.contract,
-							});
+		return makeSqlDatabase<Contract, Identifier, DatabaseLayerOptions>(identifier, (layerOptions) => {
+			const forwarded = clientOptions(layerOptions);
+			const client =
+				options.contract === undefined
+					? postgres<Contract>({
+							...forwarded,
+							contractJson: options.contractJson,
+						})
+					: postgres<Contract>({
+							...forwarded,
+							contract: options.contract,
+						});
 
-				return fromPrismaPromise(() =>
-					acquireConnectedClient(client, () => ({
-						client,
-						identity: {},
-						liveness: {
-							closedCode: "RUNTIME.DATABASE_CLOSED",
-							open: true,
-						},
-						mode: "root",
-						models: defaultModels<Contract, Models>(client),
-						querySemaphore: undefined,
-						transactionIdentity: undefined,
-						transactionSemaphore: undefined,
-					})),
-				);
-			},
-		) as DatabaseDefinition<Contract, Identifier>;
+			return fromPrismaPromise(() =>
+				acquireConnectedClient(client, () => ({
+					client,
+					identity: {},
+					liveness: {
+						closedCode: "RUNTIME.DATABASE_CLOSED",
+						open: true,
+					},
+					mode: "root",
+					models: defaultModels<Contract, Models>(client),
+					querySemaphore: undefined,
+					transactionIdentity: undefined,
+					transactionSemaphore: undefined,
+				})),
+			);
+		});
 	};

package/src/error.ts

@@ -1,31 +1,24 @@
 import { Data, Redacted } from "effect";
 
-export class PrismaRuntimeFailure extends Data.TaggedClass(
-	"PrismaRuntimeFailure",
-)<{
+export class PrismaRuntimeFailure extends Data.TaggedClass("PrismaRuntimeFailure")<{
 	readonly code: string;
 	readonly original: Redacted.Redacted<unknown>;
 }> {}
 
 export class PrismaQueryFailure extends Data.TaggedClass("PrismaQueryFailure")<{
-	readonly sqlState?: string;
-	readonly constraint?: string;
-	readonly table?: string;
-	readonly column?: string;
+	readonly sqlState?: string | undefined;
+	readonly constraint?: string | undefined;
+	readonly table?: string | undefined;
+	readonly column?: string | undefined;
 	readonly original: Redacted.Redacted<unknown>;
 }> {}
 
-export class PrismaConnectionFailure extends Data.TaggedClass(
-	"PrismaConnectionFailure",
-)<{
-	readonly transient?: boolean;
+export class PrismaConnectionFailure extends Data.TaggedClass("PrismaConnectionFailure")<{
+	readonly transient?: boolean | undefined;
 	readonly original: Redacted.Redacted<unknown>;
 }> {}
 
-export type PrismaErrorReason =
-	| PrismaRuntimeFailure
-	| PrismaQueryFailure
-	| PrismaConnectionFailure;
+export type PrismaErrorReason = PrismaRuntimeFailure | PrismaQueryFailure | PrismaConnectionFailure;
 
 export class PrismaError extends Data.TaggedError("PrismaError")<{
 	readonly reason: PrismaErrorReason;
@@ -52,10 +45,7 @@ export const isPrismaFailure = (error: unknown): error is PrismaFailure => {
 	if ("code" in error && typeof error.code === "string") {
 		return true;
 	}
-	return (
-		"kind" in error &&
-		(error.kind === "sql_query" || error.kind === "sql_connection")
-	);
+	return "kind" in error && (error.kind === "sql_query" || error.kind === "sql_connection");
 };
 
 export const toPrismaError = (error: PrismaFailure): PrismaError => {

package/src/index.ts

@@ -6,12 +6,12 @@ export {
 	type DatabaseService,
 	type DatabaseServiceOf,
 	makeDatabase,
-} from "./database.js";
+} from "./database.ts";
 export {
 	PrismaConnectionFailure,
 	PrismaError,
 	type PrismaErrorReason,
 	PrismaQueryFailure,
 	PrismaRuntimeFailure,
-} from "./error.js";
-export type { Relation } from "./relation.js";
+} from "./error.ts";
+export type { Relation } from "./relation.ts";

package/src/internal/adapters/transaction-settlement.ts

@@ -0,0 +1,67 @@
+import type { RuntimeConnection, RuntimeTransaction } from "@prisma-next/sql-runtime";
+
+export type SettledConnection = Pick<RuntimeConnection, "destroy" | "release">;
+export type SettledTransaction = Pick<RuntimeTransaction, "commit" | "rollback">;
+
+interface Settled {
+	readonly connection: SettledConnection;
+	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 });
+
+class ConnectionDisposal {
+	disposed = false;
+
+	constructor(private readonly connection: SettledConnection) {}
+
+	async destroy(reason: unknown): Promise<void> {
+		if (this.disposed) {
+			return;
+		}
+		this.disposed = true;
+		await this.connection.destroy(reason).catch(() => undefined);
+	}
+}
+
+const commit = async ({ transaction }: Settled, disposal: ConnectionDisposal): Promise<unknown> => {
+	try {
+		await transaction.commit();
+		return undefined;
+	} catch (commitError) {
+		await transaction.rollback().catch(() => disposal.destroy(commitError));
+		return runtimeFailure("RUNTIME.TRANSACTION_COMMIT_FAILED", commitError);
+	}
+};
+
+const rollback = async ({ transaction }: Settled, disposal: ConnectionDisposal): Promise<unknown> => {
+	try {
+		await transaction.rollback();
+		return undefined;
+	} catch (rollbackError) {
+		await disposal.destroy(rollbackError);
+		return runtimeFailure("RUNTIME.TRANSACTION_ROLLBACK_FAILED", rollbackError);
+	}
+};
+
+const release = async ({ connection }: Settled, disposal: ConnectionDisposal, failure: unknown): Promise<void> => {
+	if (disposal.disposed) {
+		return;
+	}
+	try {
+		await connection.release();
+	} catch (releaseError) {
+		await disposal.destroy(releaseError);
+		throw failure === undefined ? releaseError : runtimeFailure("RUNTIME.TRANSACTION_RELEASE_FAILED", failure, { releaseError });
+	}
+};
+
+export const settleConnection = async (settled: Settled, commitTransaction: boolean): Promise<void> => {
+	const disposal = new ConnectionDisposal(settled.connection);
+	const failure = commitTransaction ? await commit(settled, disposal) : await rollback(settled, disposal);
+	await release(settled, disposal, failure);
+	if (failure !== undefined) {
+		throw failure;
+	}
+};

package/src/internal/client-lifecycle.ts

@@ -3,10 +3,7 @@ export interface ClientLifecycle {
 	readonly close: () => PromiseLike<void>;
 }
 
-export const acquireConnectedClient = async <A>(
-	client: ClientLifecycle,
-	initialize: () => A,
-): Promise<A> => {
+export const acquireConnectedClient = async <A>(client: ClientLifecycle, initialize: () => A): Promise<A> => {
 	try {
 		await client.connect();
 		return initialize();
@@ -18,14 +15,10 @@ export const acquireConnectedClient = async <A>(
 
 const reservedModelNames = new Set(["transaction"]);
 
-export const assertAvailableModelNames = (
-	modelNames: ReadonlyArray<string>,
-): void => {
+export const assertAvailableModelNames = (modelNames: ReadonlyArray<string>): void => {
 	for (const modelName of modelNames) {
 		if (reservedModelNames.has(modelName)) {
-			throw new TypeError(
-				`Prisma model name conflicts with the database facade: ${modelName}`,
-			);
+			throw new TypeError(`Prisma model name conflicts with the database facade: ${modelName}`);
 		}
 	}
 };

package/src/internal/contract-normalization.ts

@@ -1,6 +1,5 @@
 const timestampReference = /\b(?:Timestamp|Timestamptz)<(?:\d+|undefined)>/g;
-const timestampCodecReference =
-	/\bCodecTypes\['pg\/(?:timestamp|timestamptz)@1'\]\['(?:input|output)'\]/g;
+const timestampCodecReference = /\bCodecTypes\['pg\/(?:timestamp|timestamptz)@1'\]\['(?:input|output)'\]/g;
 const unsupportedTimestampReference = /\b(?:Timestamp|Timestamptz)\s*</;
 
 /**
@@ -8,14 +7,10 @@ const unsupportedTimestampReference = /\b(?:Timestamp|Timestamptz)\s*</;
  * JavaScript Dates accepted and returned by its runtime codecs.
  */
 export const normalizePrismaNextContractTypes = (source: string): string => {
-	const normalized = source
-		.replaceAll(timestampReference, "Date")
-		.replaceAll(timestampCodecReference, "Date");
+	const normalized = source.replaceAll(timestampReference, "Date").replaceAll(timestampCodecReference, "Date");
 
 	if (unsupportedTimestampReference.test(normalized)) {
-		throw new Error(
-			"Unsupported Prisma Next timestamp declaration; update effect-prisma before using this generated contract",
-		);
+		throw new Error("Unsupported Prisma Next timestamp declaration; update effect-prisma before using this generated contract");
 	}
 
 	return normalized;

package/src/internal/database-facade.ts

@@ -0,0 +1,143 @@
+import { type Context, Effect } from "effect";
+import { type PrismaError, toPrismaError } from "../error.ts";
+import { assertAvailableModelNames } from "./client-lifecycle.ts";
+import type { DatabaseIdentifier, DatabaseService, DefaultModels } from "./database-types.ts";
+import type { AnySqlContract, DatabaseExecutor } from "./executor.ts";
+import { makeModelRelation } from "./relation-runtime.ts";
+import { acquireTransaction, releaseTransaction, type TransactionOrm, withTransactionSemaphore } from "./transaction.ts";
+
+export interface ActiveTransaction<Contract extends AnySqlContract, Identifier extends string> {
+	readonly executor: DatabaseExecutor<DefaultModels<Contract>, Contract>;
+	readonly facade: DatabaseService<Contract, Identifier>;
+}
+
+export interface FacadeScope<Contract extends AnySqlContract, Identifier extends string> {
+	readonly activeTransaction: Context.Reference<ActiveTransaction<Contract, Identifier> | undefined>;
+	readonly executors: WeakMap<DatabaseService<Contract, Identifier>, DatabaseExecutor<DefaultModels<Contract>, Contract>>;
+	readonly service: Context.Service<DatabaseIdentifier<Contract, Identifier>, DatabaseService<Contract, Identifier>>;
+}
+
+// Prisma Next builds each namespace's model clients from the contract, so they are the contract's DefaultModels.
+export function contractModels<Models extends object>(namespace: unknown): Models;
+export function contractModels(namespace: unknown): unknown {
+	return namespace;
+}
+
+// The facade serves `transaction` itself and a Relation for every other model name, matching DatabaseService.
+function databaseFacade<Contract extends AnySqlContract, Identifier extends string>(facade: object): DatabaseService<Contract, Identifier>;
+function databaseFacade(facade: object): unknown {
+	return facade;
+}
+
+/**
+ * Resolve the models of the single domain namespace from a namespaced ORM
+ * client. Prisma Next namespaces PostgreSQL models under their schema and
+ * SQLite models under the unbound namespace.
+ */
+export const namespaceModels = <Contract extends AnySqlContract, Models extends object>(
+	contract: Contract,
+	namespacedOrm: TransactionOrm<Contract>,
+): Models => {
+	const namespaces = Object.entries(contract.domain.namespaces);
+	const [only] = namespaces;
+	if (namespaces.length !== 1 || only === undefined) {
+		throw new TypeError("Effect Prisma currently requires exactly one domain namespace");
+	}
+	const [name, namespace] = only;
+	assertAvailableModelNames(Object.keys(namespace.models));
+	return contractModels<Models>(Reflect.get(namespacedOrm, name));
+};
+
+export const runTransaction = <Contract extends AnySqlContract, Identifier extends string, A, E, R>(
+	scope: FacadeScope<Contract, Identifier>,
+	current: DatabaseExecutor<DefaultModels<Contract>, Contract>,
+	currentFacade: DatabaseService<Contract, Identifier>,
+	program: Effect.Effect<A, E, R>,
+	release: typeof releaseTransaction,
+	mode: "test" | "transaction",
+	span: string,
+): Effect.Effect<A, E | PrismaError, Exclude<R, DatabaseIdentifier<Contract, Identifier>>> => {
+	if (!current.liveness.open) {
+		return Effect.fail(toPrismaError({ code: current.liveness.closedCode }));
+	}
+	if (current.mode === "test" || (current.mode === "transaction" && mode === "transaction")) {
+		return Effect.provideService(program, scope.service, currentFacade);
+	}
+	if (current.mode === "transaction") {
+		return Effect.fail(
+			toPrismaError({
+				code: "RUNTIME.TEST_TRANSACTION_INSIDE_TRANSACTION_UNSUPPORTED",
+			}),
+		);
+	}
+
+	const transaction = Effect.acquireUseRelease(
+		acquireTransaction(
+			current,
+			(transactionOrm) => namespaceModels<Contract, DefaultModels<Contract>>(current.client.contract, transactionOrm),
+			mode,
+		),
+		(resource) => {
+			const transactionFacade = makeFacade(scope, resource.executor);
+			return program.pipe(
+				Effect.provideService(scope.service, transactionFacade),
+				Effect.provideService(scope.activeTransaction, {
+					executor: resource.executor,
+					facade: transactionFacade,
+				}),
+			);
+		},
+		release,
+	).pipe(Effect.withSpan(span, { kind: "client" }));
+
+	return withTransactionSemaphore(current.transactionSemaphore, transaction);
+};
+
+export function makeFacade<Contract extends AnySqlContract, Identifier extends string>(
+	scope: FacadeScope<Contract, Identifier>,
+	current: DatabaseExecutor<DefaultModels<Contract>, Contract>,
+): DatabaseService<Contract, Identifier> {
+	let facade: DatabaseService<Contract, Identifier>;
+	const resolveActiveTransaction = Effect.flatMap(scope.activeTransaction, (active) => {
+		if (current.mode === "root") {
+			return Effect.succeed(active ?? { executor: current, facade });
+		}
+		return active?.executor === current
+			? Effect.succeed(active)
+			: Effect.fail(
+					toPrismaError({
+						code: "RUNTIME.TRANSACTION_CONTEXT_MISMATCH",
+					}),
+				);
+	});
+	const resolveExecutor = Effect.suspend(() =>
+		current.liveness.open ? Effect.map(resolveActiveTransaction, ({ executor }) => executor) : Effect.succeed(current),
+	);
+	const target: object = Object.create(null);
+	Object.assign(target, {
+		transaction: <A, E, R>(program: Effect.Effect<A, E, R> & (DatabaseIdentifier<Contract, Identifier> extends R ? unknown : never)) =>
+			Effect.suspend(() => {
+				if (!current.liveness.open) {
+					return Effect.fail(toPrismaError({ code: current.liveness.closedCode }));
+				}
+				return Effect.flatMap(resolveActiveTransaction, (selected) =>
+					runTransaction(scope, selected.executor, selected.facade, program, releaseTransaction, "transaction", "prisma.transaction"),
+				);
+			}),
+	});
+	facade = databaseFacade<Contract, Identifier>(
+		new Proxy(target, {
+			get(target, property, receiver) {
+				if (Reflect.has(target, property)) {
+					return Reflect.get(target, property, receiver);
+				}
+				if (typeof property !== "string") {
+					return undefined;
+				}
+				return makeModelRelation(current, property, resolveExecutor);
+			},
+		}),
+	);
+	scope.executors.set(facade, current);
+	return facade;
+}