@shivaedev/effect-prisma 0.0.0 → 0.2.0

package/src/error.ts

@@ -0,0 +1,89 @@
+import { Data, Redacted } from "effect";
+
+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 original: Redacted.Redacted<unknown>;
+}> {}
+
+export class PrismaConnectionFailure extends Data.TaggedClass(
+	"PrismaConnectionFailure",
+)<{
+	readonly transient?: boolean;
+	readonly original: Redacted.Redacted<unknown>;
+}> {}
+
+export type PrismaErrorReason =
+	| PrismaRuntimeFailure
+	| PrismaQueryFailure
+	| PrismaConnectionFailure;
+
+export class PrismaError extends Data.TaggedError("PrismaError")<{
+	readonly reason: PrismaErrorReason;
+}> {}
+
+type PrismaFailure =
+	| { readonly code: string }
+	| {
+			readonly kind: "sql_query";
+			readonly sqlState?: string;
+			readonly constraint?: string;
+			readonly table?: string;
+			readonly column?: string;
+	  }
+	| {
+			readonly kind: "sql_connection";
+			readonly transient?: boolean;
+	  };
+
+export const isPrismaFailure = (error: unknown): error is PrismaFailure => {
+	if (typeof error !== "object" || error === null) {
+		return false;
+	}
+	if ("code" in error && typeof error.code === "string") {
+		return true;
+	}
+	return (
+		"kind" in error &&
+		(error.kind === "sql_query" || error.kind === "sql_connection")
+	);
+};
+
+export const toPrismaError = (error: PrismaFailure): PrismaError => {
+	const original = Redacted.make(error);
+
+	if ("kind" in error && error.kind === "sql_query") {
+		return new PrismaError({
+			reason: new PrismaQueryFailure({
+				sqlState: error.sqlState,
+				constraint: error.constraint,
+				table: error.table,
+				column: error.column,
+				original,
+			}),
+		});
+	}
+	if ("kind" in error && error.kind === "sql_connection") {
+		return new PrismaError({
+			reason: new PrismaConnectionFailure({
+				transient: error.transient,
+				original,
+			}),
+		});
+	}
+	return new PrismaError({
+		reason: new PrismaRuntimeFailure({
+			code: error.code,
+			original,
+		}),
+	});
+};

package/src/index.ts

@@ -0,0 +1,14 @@
+export {
+	type DatabaseDefinition,
+	type DatabaseLayerOptions,
+	type DatabaseService,
+	makeDatabase,
+} from "./database.js";
+export {
+	PrismaConnectionFailure,
+	PrismaError,
+	type PrismaErrorReason,
+	PrismaQueryFailure,
+	PrismaRuntimeFailure,
+} from "./error.js";
+export type { Relation } from "./relation.js";

package/src/internal/client-lifecycle.ts

@@ -0,0 +1,31 @@
+export interface ClientLifecycle {
+	readonly connect: () => PromiseLike<unknown>;
+	readonly close: () => PromiseLike<void>;
+}
+
+export const acquireConnectedClient = async <A>(
+	client: ClientLifecycle,
+	initialize: () => A,
+): Promise<A> => {
+	try {
+		await client.connect();
+		return initialize();
+	} catch (error) {
+		await Promise.resolve(client.close()).catch(() => undefined);
+		throw error;
+	}
+};
+
+const reservedModelNames = new Set(["transaction"]);
+
+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}`,
+			);
+		}
+	}
+};

package/src/internal/executor.ts

@@ -0,0 +1,28 @@
+import type { Contract as PrismaContract } from "@prisma-next/contract/types";
+import type { PostgresClient } from "@prisma-next/postgres/runtime";
+import type { SqlStorage } from "@prisma-next/sql-contract/types";
+import type { Context } from "effect";
+
+export type AnyPostgresContract = PrismaContract<SqlStorage>;
+
+export interface DatabaseExecutor<
+	Models extends object,
+	Contract extends AnyPostgresContract = AnyPostgresContract,
+> {
+	readonly client: PostgresClient<Contract>;
+	readonly models: Models;
+	readonly transactional: boolean;
+}
+
+export type ExecutorService<
+	Models extends object,
+	Contract extends AnyPostgresContract = AnyPostgresContract,
+> = Context.Service<
+	ExecutorIdentifier<Models>,
+	DatabaseExecutor<Models, Contract>
+>;
+
+export interface ExecutorIdentifier<Models extends object> {
+	readonly _models: Models;
+	readonly _executorIdentifier: unique symbol;
+}

package/src/internal/promise.ts

@@ -0,0 +1,16 @@
+import { Effect } from "effect";
+import { isPrismaFailure, type PrismaError, toPrismaError } from "../error.js";
+
+export const fromPrismaPromise = <A>(
+	evaluate: (signal: AbortSignal) => PromiseLike<A>,
+): Effect.Effect<A, PrismaError> =>
+	Effect.tryPromise({
+		try: (signal) => Promise.resolve(evaluate(signal)),
+		catch: (error) => error,
+	}).pipe(
+		Effect.catch((error) =>
+			isPrismaFailure(error)
+				? Effect.fail(toPrismaError(error))
+				: Effect.die(error),
+		),
+	);

package/src/internal/recipe.ts

@@ -0,0 +1,148 @@
+import { getRelationPlan, type RelationPlan } from "./relation-plan.js";
+
+export interface RelationOperation {
+	readonly name: PropertyKey;
+	readonly arguments: ReadonlyArray<unknown>;
+}
+
+export interface RelationRecipe {
+	readonly model: string;
+	readonly parent?: RelationRecipe;
+	readonly operation?: RelationOperation;
+}
+
+export const rootRecipe = (model: string): RelationRecipe => ({ model });
+
+export const appendOperation = (
+	parent: RelationRecipe,
+	name: PropertyKey,
+	arguments_: ReadonlyArray<unknown>,
+): RelationRecipe => ({
+	model: parent.model,
+	parent,
+	operation: {
+		name,
+		arguments: arguments_,
+	},
+});
+
+const operations = (
+	recipe: RelationRecipe,
+): ReadonlyArray<RelationOperation> => {
+	const reversed: Array<RelationOperation> = [];
+	let current: RelationRecipe | undefined = recipe;
+
+	while (current !== undefined) {
+		if (current.operation !== undefined) {
+			reversed.push(current.operation);
+		}
+		current = current.parent;
+	}
+
+	return reversed.reverse();
+};
+
+const applyMethod = (
+	current: unknown,
+	name: PropertyKey,
+	arguments_: ReadonlyArray<unknown>,
+	model: string,
+): unknown => {
+	if (
+		typeof current !== "object" ||
+		current === null ||
+		typeof Reflect.get(current, name) !== "function"
+	) {
+		throw new TypeError(`Cannot call ${String(name)} while replaying ${model}`);
+	}
+
+	const method = Reflect.get(current, name) as (
+		...arguments_: ReadonlyArray<unknown>
+	) => unknown;
+	return Reflect.apply(method, current, arguments_);
+};
+
+const replayPlan = (collection: unknown, plan: RelationPlan): unknown => {
+	const relatedModel =
+		typeof collection === "object" && collection !== null
+			? Reflect.get(collection, "modelName")
+			: undefined;
+	if (typeof relatedModel === "string" && relatedModel !== plan.recipe.model) {
+		throw new TypeError(
+			`Included relation expects ${relatedModel}, received ${plan.recipe.model}`,
+		);
+	}
+
+	const refined = replayRecipeFrom(collection, plan.recipe);
+	if (plan.terminal !== "count") {
+		return refined;
+	}
+	return applyMethod(refined, "count", [], plan.recipe.model);
+};
+
+const includeRefinement = (
+	value: unknown,
+): ((collection: unknown) => unknown) => {
+	const plan = getRelationPlan(value);
+	if (plan !== undefined) {
+		return (collection) => replayPlan(collection, plan);
+	}
+
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		throw new TypeError(
+			"An included relation must be a Relation or query record",
+		);
+	}
+
+	const entries = Object.entries(value);
+	if (entries.length === 0) {
+		throw new TypeError("An included query record cannot be empty");
+	}
+
+	const plans = entries.map(([name, query]) => {
+		const queryPlan = getRelationPlan(query);
+		if (queryPlan === undefined) {
+			throw new TypeError(`Included query "${name}" is not a Relation`);
+		}
+		return [name, queryPlan] as const;
+	});
+	const model = plans[0]?.[1].recipe.model;
+	if (plans.some(([, queryPlan]) => queryPlan.recipe.model !== model)) {
+		throw new TypeError("Included queries must use the same related model");
+	}
+
+	return (collection) => {
+		const branches = Object.fromEntries(
+			plans.map(([name, queryPlan]) => [
+				name,
+				replayPlan(collection, queryPlan),
+			]),
+		);
+		return applyMethod(collection, "combine", [branches], model ?? "relation");
+	};
+};
+
+const replayRecipeFrom = (root: unknown, recipe: RelationRecipe): unknown => {
+	let current = root;
+	for (const operation of operations(recipe)) {
+		const arguments_ =
+			operation.name === "include" && operation.arguments.length === 2
+				? [operation.arguments[0], includeRefinement(operation.arguments[1])]
+				: operation.arguments;
+		current = applyMethod(current, operation.name, arguments_, recipe.model);
+	}
+	return current;
+};
+
+export const replayRecipe = (
+	models: object,
+	recipe: RelationRecipe,
+): unknown => {
+	const current: unknown = Reflect.get(models, recipe.model);
+
+	if (current === undefined) {
+		throw new TypeError(`Unknown Prisma model: ${recipe.model}`);
+	}
+
+	return replayRecipeFrom(current, recipe);
+};

package/src/internal/relation-plan.ts

@@ -0,0 +1,22 @@
+import type { RelationRecipe } from "./recipe.js";
+
+export const RelationPlanTypeId = Symbol.for(
+	"@shivaedev/effect-prisma/RelationPlan",
+);
+
+export interface RelationPlan {
+	readonly recipe: RelationRecipe;
+	readonly terminal?: PropertyKey;
+}
+
+export const getRelationPlan = (value: unknown): RelationPlan | undefined => {
+	if (
+		typeof value !== "object" ||
+		value === null ||
+		!Reflect.has(value, RelationPlanTypeId)
+	) {
+		return undefined;
+	}
+
+	return Reflect.get(value, RelationPlanTypeId) as RelationPlan;
+};

package/src/internal/relation-runtime.ts

@@ -0,0 +1,249 @@
+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";
+import { RelationPlanTypeId } from "./relation-plan.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 === "count" &&
+		typeof value === "object" &&
+		value !== null &&
+		typeof Reflect.get(value, "aggregate") === "function"
+	) {
+		const aggregate = Reflect.apply(
+			Reflect.get(value, "aggregate") as AnyFunction,
+			value,
+			[(summary: { count(): unknown }) => ({ count: summary.count() })],
+		);
+		return fromPrismaPromise(
+			() => aggregate as PromiseLike<{ count: number }>,
+		).pipe(Effect.map((result) => result.count));
+	}
+
+	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 [RelationPlanTypeId]: {
+		readonly recipe: RelationRecipe;
+		readonly terminal?: PropertyKey;
+	};
+	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), {
+		[RelationPlanTypeId]: {
+			recipe: runtime.recipe,
+			...(runtime.terminal === undefined ? {} : { terminal: runtime.terminal }),
+		},
+		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",
+					});
+			}
+			if (property === "count") {
+				return () =>
+					makeRelationProxy({
+						...runtime,
+						terminal: "count",
+					});
+			}
+			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;
+};