@shivaedev/effect-prisma 0.0.0 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/effect-prisma",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "description": "Effect-native PostgreSQL queries and transactions for Prisma Next",
   "type": "module",
   "license": "MIT",
@@ -9,10 +9,75 @@
     "url": "git+https://github.com/ShivaeDev/platform.git",
     "directory": "packages/effect-prisma"
   },
-  "publishConfig": {
-    "access": "public"
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/effect-prisma#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
+  "engines": {
+    "node": ">=24"
   },
+  "sideEffects": false,
   "files": [
+    "dist",
+    "src",
+    "CHANGELOG.md",
     "README.md"
-  ]
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "source": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "source": "./src/testing.ts",
+      "import": "./dist/testing.js",
+      "default": "./dist/testing.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@prisma-next/contract": "0.15.0",
+    "@prisma-next/postgres": "0.15.0",
+    "@prisma-next/sql-contract": "0.15.0",
+    "@prisma-next/sql-orm-client": "0.15.0",
+    "@prisma-next/sql-relational-core": "0.15.0",
+    "@prisma-next/sql-runtime": "0.15.0"
+  },
+  "peerDependencies": {
+    "@effect/vitest": "4.0.0-beta.99",
+    "effect": "4.0.0-beta.99"
+  },
+  "peerDependenciesMeta": {
+    "@effect/vitest": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-beta.99",
+    "@prisma-next/adapter-postgres": "0.15.0",
+    "@prisma-next/cli": "0.15.0",
+    "@prisma-next/target-postgres": "0.15.0",
+    "@types/node": "24.10.1",
+    "@types/pg": "8.20.0",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "effect": "4.0.0-beta.99",
+    "typescript": "npm:@typescript/typescript6@6.0.2",
+    "vitest": "4.1.9"
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc6 --project tsconfig.build.json",
+    "check": "biome check .",
+    "test": "vitest run",
+    "test:package": "node scripts/test-package.mjs",
+    "typecheck": "tsc --noEmit",
+    "typecheck:compat": "tsc6 --noEmit",
+    "ready": "pnpm check && pnpm typecheck && pnpm typecheck:compat && pnpm test && pnpm build && pnpm test:package"
+  }
 }

package/src/database.ts

@@ -0,0 +1,232 @@
+import postgres, {
+	type PostgresClient,
+	type PostgresOptionsBase,
+} from "@prisma-next/postgres/runtime";
+import { Context, Effect, Layer, Redacted } from "effect";
+import type { PrismaError } from "./error.js";
+import {
+	acquireConnectedClient,
+	assertAvailableModelNames,
+} from "./internal/client-lifecycle.js";
+import type {
+	AnyPostgresContract,
+	DatabaseExecutor,
+	ExecutorIdentifier,
+} from "./internal/executor.js";
+import { fromPrismaPromise } from "./internal/promise.js";
+import { makeModelRelation } from "./internal/relation-runtime.js";
+import { DatabaseTestingTypeId } from "./internal/testing.js";
+import {
+	acquireTransaction,
+	releaseTestTransaction,
+	releaseTransaction,
+} from "./internal/transaction.js";
+import type { Relation } from "./relation.js";
+
+type ClientFor<Contract extends AnyPostgresContract> = PostgresClient<Contract>;
+type OrmFor<Contract extends AnyPostgresContract> = ClientFor<Contract>["orm"];
+type DefaultNamespaceId<Contract extends AnyPostgresContract> =
+	"__unbound__" extends keyof OrmFor<Contract>
+		? "__unbound__"
+		: "public" extends keyof OrmFor<Contract>
+			? "public"
+			: keyof OrmFor<Contract>;
+type DefaultModels<Contract extends AnyPostgresContract> =
+	OrmFor<Contract>[DefaultNamespaceId<Contract>] extends infer Models extends
+		object
+		? Models
+		: never;
+
+interface DatabaseIdentifier<Contract extends AnyPostgresContract> {
+	readonly _contract: Contract;
+	readonly _databaseIdentifier: unique symbol;
+}
+
+type DatabaseModels<Contract extends AnyPostgresContract, Requirement> = {
+	readonly [Model in keyof DefaultModels<Contract>]: Relation<
+		DefaultModels<Contract>[Model],
+		Requirement,
+		Contract,
+		Model & string
+	>;
+};
+
+export type DatabaseService<
+	Contract extends AnyPostgresContract,
+	Requirement,
+> = DatabaseModels<Contract, Requirement> & {
+	transaction<A, E, R>(
+		program: Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | PrismaError, R | Requirement>;
+};
+
+export interface DatabaseLayerOptions extends PostgresOptionsBase {
+	readonly url: string | Redacted.Redacted<string>;
+}
+
+type DatabaseFactoryOptions<Contract extends AnyPostgresContract> =
+	| {
+			readonly contract: Contract;
+			readonly contractJson?: never;
+	  }
+	| {
+			readonly contractJson: unknown;
+			readonly contract?: never;
+	  };
+
+export interface DatabaseDefinition<
+	Contract extends AnyPostgresContract,
+	Requirement = ExecutorIdentifier<DefaultModels<Contract>>,
+> extends Context.Service<
+		DatabaseIdentifier<Contract>,
+		DatabaseService<Contract, Requirement>
+	> {
+	readonly layer: (
+		options: DatabaseLayerOptions,
+	) => Layer.Layer<DatabaseIdentifier<Contract> | Requirement, PrismaError>;
+}
+
+const defaultModels = <
+	Contract extends AnyPostgresContract,
+	Models extends object,
+>(
+	client: Pick<PostgresClient<Contract>, "contract" | "orm">,
+): Models => {
+	const namespaces = Object.keys(client.contract.domain.namespaces);
+	if (namespaces.length !== 1 || namespaces[0] === undefined) {
+		throw new TypeError(
+			"Effect Prisma currently requires exactly one domain namespace",
+		);
+	}
+	assertAvailableModelNames(
+		Object.keys(client.contract.domain.namespaces[namespaces[0]].models),
+	);
+	return Reflect.get(client.orm, namespaces[0]) as Models;
+};
+
+export const makeDatabase = <const Contract extends AnyPostgresContract>(
+	identifier: string,
+	options: DatabaseFactoryOptions<Contract>,
+): DatabaseDefinition<Contract> => {
+	type Models = DefaultModels<Contract>;
+	type ExecutorId = ExecutorIdentifier<Models>;
+	type DatabaseId = DatabaseIdentifier<Contract>;
+
+	const Executor = Context.Service<
+		ExecutorId,
+		DatabaseExecutor<Models, Contract>
+	>(`${identifier}/Executor`);
+	const Service = Context.Service<
+		DatabaseId,
+		DatabaseService<Contract, ExecutorId>
+	>(identifier);
+
+	const transaction = <A, E, R>(
+		program: Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | PrismaError, R | ExecutorId> =>
+		Effect.flatMap(Executor, (current) => {
+			if (current.transactional) {
+				return program;
+			}
+
+			return Effect.acquireUseRelease(
+				acquireTransaction(current, (transactionOrm) =>
+					defaultModels<Contract, Models>({
+						contract: current.client.contract,
+						orm: transactionOrm,
+					}),
+				),
+				(resource) =>
+					program.pipe(Effect.provideService(Executor, resource.executor)),
+				releaseTransaction,
+			).pipe(Effect.withSpan("prisma.transaction", { kind: "client" }));
+		});
+
+	const withTestTransaction = <A, E, R>(
+		program: Effect.Effect<A, E, R>,
+	): Effect.Effect<A, E | PrismaError, R | ExecutorId> =>
+		Effect.flatMap(Executor, (current) => {
+			if (current.transactional) {
+				return program;
+			}
+
+			return Effect.acquireUseRelease(
+				acquireTransaction(current, (transactionOrm) =>
+					defaultModels<Contract, Models>({
+						contract: current.client.contract,
+						orm: transactionOrm,
+					}),
+				),
+				(resource) =>
+					program.pipe(Effect.provideService(Executor, resource.executor)),
+				releaseTestTransaction,
+			).pipe(Effect.withSpan("prisma.testTransaction", { kind: "client" }));
+		});
+
+	const facade = new Proxy(
+		Object.assign(Object.create(null), {
+			transaction,
+		}) as DatabaseService<Contract, ExecutorId>,
+		{
+			get(target, property, receiver) {
+				if (Reflect.has(target, property)) {
+					return Reflect.get(target, property, receiver);
+				}
+				if (typeof property !== "string") {
+					return undefined;
+				}
+				return makeModelRelation(Executor, property);
+			},
+		},
+	);
+
+	const layer = (
+		layerOptions: DatabaseLayerOptions,
+	): Layer.Layer<DatabaseId | ExecutorId, PrismaError> => {
+		const acquire = Effect.acquireRelease(
+			Effect.suspend(() => {
+				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 fromPrismaPromise(() =>
+					acquireConnectedClient(client, () => ({
+						client,
+						models: defaultModels<Contract, Models>(client),
+						transactional: false,
+					})),
+				);
+			}),
+			(executor) =>
+				Effect.promise(() => executor.client.close()).pipe(Effect.orDie),
+		);
+
+		return Layer.effectContext(
+			Effect.map(acquire, (executor) =>
+				Context.make(Executor, executor).pipe(Context.add(Service, facade)),
+			),
+		);
+	};
+
+	return Object.assign(Service, {
+		layer,
+		[DatabaseTestingTypeId]: { withTestTransaction },
+	}) as DatabaseDefinition<Contract>;
+};

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,71 @@
+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();
+};
+
+export const replayRecipe = (
+	models: object,
+	recipe: RelationRecipe,
+): unknown => {
+	let current: unknown = Reflect.get(models, recipe.model);
+
+	if (current === undefined) {
+		throw new TypeError(`Unknown Prisma model: ${recipe.model}`);
+	}
+
+	for (const operation of operations(recipe)) {
+		if (
+			typeof current !== "object" ||
+			current === null ||
+			typeof Reflect.get(current, operation.name) !== "function"
+		) {
+			throw new TypeError(
+				`Cannot call ${String(operation.name)} while replaying ${recipe.model}`,
+			);
+		}
+
+		const method = Reflect.get(current, operation.name) as (
+			...arguments_: ReadonlyArray<unknown>
+		) => unknown;
+		current = Reflect.apply(method, current, operation.arguments);
+	}
+
+	return current;
+};