@shivaedev/effect-prisma 0.7.1 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivaedev/effect-prisma",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "Effect-native PostgreSQL queries and transactions for Prisma Next",
   "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/effect-prisma#readme",
   "bugs": {
@@ -15,7 +15,7 @@
   "sideEffects": false,
   "type": "module",
   "imports": {
-    "#test/*": "./test/*",
+    "#test/*": "./src/test-support/*",
     "#*.ts": {
       "source": "./src/*.ts",
       "types": "./dist/*.d.ts",
@@ -23,24 +23,13 @@
     }
   },
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "source": "./src/index.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    },
-    "./sqlite": {
-      "types": "./dist/sqlite.d.ts",
-      "source": "./src/sqlite.ts",
-      "import": "./dist/sqlite.js",
-      "default": "./dist/sqlite.js"
-    },
-    "./testing": {
-      "types": "./dist/testing.d.ts",
-      "source": "./src/testing.ts",
-      "import": "./dist/testing.js",
-      "default": "./dist/testing.js"
+    "./*.ts": {
+      "types": "./dist/*.d.ts",
+      "source": "./src/*.ts",
+      "import": "./dist/*.js",
+      "default": "./dist/*.js"
     },
+    "./internal/*": null,
     "./package.json": "./package.json"
   },
   "bin": {
@@ -49,37 +38,41 @@
   "files": [
     "dist",
     "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/test-support",
+    "docs",
     "CHANGELOG.md",
     "README.md"
   ],
   "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",
-    "@prisma-next/sqlite": "0.15.0",
-    "@shivaedev/effect-test": "0.1.3"
+    "@prisma-next/contract": "0.16.0",
+    "@prisma-next/postgres": "0.16.0",
+    "@prisma-next/sql-contract": "0.16.0",
+    "@prisma-next/sql-orm-client": "0.16.0",
+    "@prisma-next/sql-relational-core": "0.16.0",
+    "@prisma-next/sql-runtime": "0.16.0",
+    "@prisma-next/sqlite": "0.16.0",
+    "@shivaedev/effect-test": "0.4.0"
   },
   "devDependencies": {
-    "@effect/vitest": "4.0.0-rc.112",
-    "@prisma-next/adapter-postgres": "0.15.0",
-    "@prisma-next/adapter-sqlite": "0.15.0",
-    "@prisma-next/cli": "0.15.0",
-    "@prisma-next/target-postgres": "0.15.0",
-    "@prisma-next/target-sqlite": "0.15.0",
-    "@shivaedev/quality": "0.7.3",
-    "@types/node": "24.10.1",
+    "@effect/vitest": "4.0.4",
+    "@prisma-next/adapter-postgres": "0.16.0",
+    "@prisma-next/adapter-sqlite": "0.16.0",
+    "@prisma-next/cli": "0.16.0",
+    "@prisma-next/target-postgres": "0.16.0",
+    "@prisma-next/target-sqlite": "0.16.0",
+    "@shivaedev/quality": "0.20.0",
+    "@types/node": "24.19.1",
     "@types/pg": "8.20.0",
     "@typescript/native": "npm:typescript@7.0.2",
-    "effect": "4.0.0-rc.112",
+    "effect": "4.0.4",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "vitest": "4.1.9"
+    "vitest": "5.0.3"
   },
   "peerDependencies": {
-    "@effect/vitest": "4.0.0-rc.112",
-    "effect": "4.0.0-rc.112"
+    "@effect/vitest": "4.0.4",
+    "effect": "4.0.4"
   },
   "peerDependenciesMeta": {
     "@effect/vitest": {
@@ -94,7 +87,7 @@
     "provenance": true
   },
   "scripts": {
-    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc6 --project tsconfig.build.json",
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc --project tsconfig.build.json",
     "ready": "pnpm typecheck && pnpm test && pnpm build",
     "test": "vitest run",
     "typecheck": "tsc --noEmit"

package/src/database.ts

@@ -1,26 +1,20 @@
 import postgres, { type PostgresClient, type PostgresOptionsBase } from "@prisma-next/postgres/runtime";
 import { type Layer, Redacted } from "effect";
+import type { DatabaseIdentifier, DatabaseIdentifierLiteral, DatabaseServiceHolder, DefaultModels } from "#databaseTypes.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";
 import type { PrismaError } from "./error.ts";
 
-export type {
-	AnyDatabase,
-	DatabaseService,
-	DatabaseServiceOf,
-} from "#internal/database-types.ts";
-
 export interface DatabaseLayerOptions extends PostgresOptionsBase {
 	readonly url: string | Redacted.Redacted<string>;
 }
 
-type DatabaseFactoryOptions<Contract extends AnySqlContract> =
+type DatabaseFactoryOptions<TContract extends AnySqlContract> =
 	| {
-			readonly contract: Contract;
+			readonly contract: TContract;
 			readonly contractJson?: never;
 	  }
 	| {
@@ -28,38 +22,44 @@ 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<TContract extends AnySqlContract, TIdentifier extends string>
+	extends DatabaseServiceHolder<TContract, TIdentifier> {
+	readonly layer: (options: DatabaseLayerOptions) => Layer.Layer<DatabaseIdentifier<TContract, TIdentifier>, PrismaError>;
 }
 
-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 }),
-});
+function clientOptions({ url, extensions, middleware, poolOptions, verifyMarker }: DatabaseLayerOptions) {
+	return {
+		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);
+function defaultModels<TContract extends AnySqlContract, TModels extends object>(
+	client: Pick<PostgresClient<TContract>, "contract" | "orm">,
+): TModels {
+	return namespaceModels<TContract, TModels>(client.contract, client.orm);
+}
 
 export const makeDatabase =
-	<const Contract extends AnySqlContract>() =>
-	<const Identifier extends string>(
-		identifier: DatabaseIdentifierLiteral<Identifier>,
-		options: DatabaseFactoryOptions<Contract>,
-	): DatabaseDefinition<Contract, Identifier> => {
-		type Models = DefaultModels<Contract>;
+	<const TContract extends AnySqlContract>() =>
+	<const TIdentifier extends string>(
+		identifier: DatabaseIdentifierLiteral<TIdentifier>,
+		options: DatabaseFactoryOptions<TContract>,
+	): DatabaseDefinition<TContract, TIdentifier> => {
+		type Models = DefaultModels<TContract>;
 
-		return makeSqlDatabase<Contract, Identifier, DatabaseLayerOptions>(identifier, (layerOptions) => {
+		return makeSqlDatabase<TContract, TIdentifier, DatabaseLayerOptions>(identifier, (layerOptions) => {
 			const forwarded = clientOptions(layerOptions);
 			const client =
 				options.contract === undefined
-					? postgres<Contract>({
+					? postgres<TContract>({
 							...forwarded,
 							contractJson: options.contractJson,
 						})
-					: postgres<Contract>({
+					: postgres<TContract>({
 							...forwarded,
 							contract: options.contract,
 						});
@@ -73,7 +73,7 @@ export const makeDatabase =
 						open: true,
 					},
 					mode: "root",
-					models: defaultModels<Contract, Models>(client),
+					models: defaultModels<TContract, Models>(client),
 					querySemaphore: undefined,
 					transactionIdentity: undefined,
 					transactionSemaphore: undefined,

package/src/databaseTypes.ts

@@ -0,0 +1,65 @@
+import type { orm } from "@prisma-next/sql-orm-client";
+import type { Context, Effect, Layer } from "effect";
+import type { PrismaError } from "#error.ts";
+import type { AnySqlContract } from "#internal/executor.ts";
+import type { Relation } from "#relation.ts";
+
+type OrmFor<TContract extends AnySqlContract> = ReturnType<typeof orm<TContract>>;
+type DefaultNamespaceId<TContract extends AnySqlContract> = "__unbound__" extends keyof OrmFor<TContract>
+	? "__unbound__"
+	: "public" extends keyof OrmFor<TContract>
+		? "public"
+		: keyof OrmFor<TContract>;
+export type DefaultModels<TContract extends AnySqlContract> = OrmFor<TContract>[DefaultNamespaceId<TContract>] extends infer TModels extends object
+	? TModels
+	: never;
+
+type IsUnion<TValue, TWhole = TValue> = TValue extends unknown ? ([TWhole] extends [TValue] ? false : true) : never;
+
+type IsSingletonString<TValue extends string> = Record<never, never> extends Record<TValue, never> ? false : true;
+
+export const internalContextIdentifierPrefix = "\0@shivaedev/effect-prisma/internal/";
+
+export type DatabaseIdentifierLiteral<TIdentifier extends string> = [TIdentifier] extends [`\0@shivaedev/effect-prisma/internal/${string}`]
+	? never
+	: string extends TIdentifier
+		? never
+		: true extends IsUnion<TIdentifier>
+			? never
+			: IsSingletonString<TIdentifier> extends true
+				? TIdentifier
+				: never;
+
+export interface DatabaseIdentifier<TContract extends AnySqlContract, TIdentifier extends string> {
+	readonly _contract: (contract: TContract) => TContract;
+	readonly _databaseIdentifier: (identifier: TIdentifier) => TIdentifier;
+}
+
+type DatabaseModels<TContract extends AnySqlContract, TIdentifier extends string> = {
+	readonly [TModel in keyof DefaultModels<TContract>]: Relation<
+		DefaultModels<TContract>[TModel],
+		TContract,
+		TModel & string,
+		DatabaseIdentifier<TContract, TIdentifier>
+	>;
+};
+
+export type DatabaseService<TContract extends AnySqlContract, TIdentifier extends string> = DatabaseModels<TContract, TIdentifier> & {
+	transaction: <A, E, R>(
+		program: Effect.Effect<A, E, R> & (DatabaseIdentifier<TContract, TIdentifier> extends R ? unknown : never),
+	) => Effect.Effect<A, E | PrismaError, Exclude<R, DatabaseIdentifier<TContract, TIdentifier>>>;
+};
+
+export interface DatabaseServiceHolder<TContract extends AnySqlContract, TIdentifier extends string>
+	extends Context.Service<DatabaseIdentifier<TContract, TIdentifier>, DatabaseService<TContract, TIdentifier>> {}
+
+export type AnyDatabase = Effect.Effect<unknown, never, unknown> & {
+	readonly layer: (...arguments_: readonly never[]) => Layer.Any;
+};
+
+export type DatabaseServiceOf<TDatabase extends AnyDatabase> = Effect.Success<TDatabase>;
+
+export interface SqlDatabase<TContract extends AnySqlContract, TIdentifier extends string, TOptions>
+	extends DatabaseServiceHolder<TContract, TIdentifier> {
+	readonly layer: (options: TOptions) => Layer.Layer<DatabaseIdentifier<TContract, TIdentifier>, PrismaError>;
+}

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

@@ -8,8 +8,9 @@ interface Settled {
 	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 });
+function runtimeFailure(code: string, cause: unknown, details?: Readonly<Record<string, unknown>>): Error & { readonly code: string } {
+	return Object.assign(new Error(code, { cause }), { code, ...details });
+}
 
 class ConnectionDisposal {
 	disposed = false;
@@ -28,7 +29,7 @@ class ConnectionDisposal {
 	}
 }
 
-const commit = async ({ transaction }: Settled, disposal: ConnectionDisposal): Promise<unknown> => {
+async function commit({ transaction }: Settled, disposal: ConnectionDisposal): Promise<unknown> {
 	try {
 		await transaction.commit();
 		return undefined;
@@ -36,9 +37,9 @@ const commit = async ({ transaction }: Settled, disposal: ConnectionDisposal): P
 		await transaction.rollback().catch(() => disposal.destroy(commitError));
 		return runtimeFailure("RUNTIME.TRANSACTION_COMMIT_FAILED", commitError);
 	}
-};
+}
 
-const rollback = async ({ transaction }: Settled, disposal: ConnectionDisposal): Promise<unknown> => {
+async function rollback({ transaction }: Settled, disposal: ConnectionDisposal): Promise<unknown> {
 	try {
 		await transaction.rollback();
 		return undefined;
@@ -46,9 +47,9 @@ const rollback = async ({ transaction }: Settled, disposal: ConnectionDisposal):
 		await disposal.destroy(rollbackError);
 		return runtimeFailure("RUNTIME.TRANSACTION_ROLLBACK_FAILED", rollbackError);
 	}
-};
+}
 
-const release = async ({ connection }: Settled, disposal: ConnectionDisposal, failure: unknown): Promise<void> => {
+async function release({ connection }: Settled, disposal: ConnectionDisposal, failure: unknown): Promise<void> {
 	if (disposal.disposed) {
 		return;
 	}
@@ -58,7 +59,7 @@ const release = async ({ connection }: Settled, disposal: ConnectionDisposal, fa
 		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);

package/src/internal/database-facade.ts

@@ -1,38 +1,38 @@
 import { type Context, Effect } from "effect";
+import type { DatabaseIdentifier, DatabaseService, DefaultModels } from "#databaseTypes.ts";
 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 ActiveTransaction<TContract extends AnySqlContract, TIdentifier extends string> {
+	readonly executor: DatabaseExecutor<DefaultModels<TContract>, TContract>;
+	readonly facade: DatabaseService<TContract, TIdentifier>;
 }
 
-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>>;
+export interface FacadeScope<TContract extends AnySqlContract, TIdentifier extends string> {
+	readonly activeTransaction: Context.Reference<ActiveTransaction<TContract, TIdentifier> | undefined>;
+	readonly executors: WeakMap<DatabaseService<TContract, TIdentifier>, DatabaseExecutor<DefaultModels<TContract>, TContract>>;
+	readonly service: Context.Service<DatabaseIdentifier<TContract, TIdentifier>, DatabaseService<TContract, TIdentifier>>;
 }
 
 // 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<TModels extends object>(namespace: unknown): TModels;
 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<TContract extends AnySqlContract, TIdentifier extends string>(facade: object): DatabaseService<TContract, TIdentifier>;
 function databaseFacade(facade: object): unknown {
 	return facade;
 }
 
-export const namespaceModels = <Contract extends AnySqlContract, Models extends object>(
-	contract: Contract,
-	namespacedOrm: TransactionOrm<Contract>,
-): Models => {
+export const namespaceModels = <TContract extends AnySqlContract, TModels extends object>(
+	contract: TContract,
+	namespacedOrm: TransactionOrm<TContract>,
+): TModels => {
 	const namespaces = Object.entries(contract.domain.namespaces);
 	const [only] = namespaces;
 	if (namespaces.length !== 1 || only === undefined) {
@@ -40,18 +40,18 @@ export const namespaceModels = <Contract extends AnySqlContract, Models extends
 	}
 	const [postgresSchemaOrSqliteUnbound, namespace] = only;
 	assertAvailableModelNames(Object.keys(namespace.models));
-	return contractModels<Models>(Reflect.get(namespacedOrm, postgresSchemaOrSqliteUnbound));
+	return contractModels<TModels>(Reflect.get(namespacedOrm, postgresSchemaOrSqliteUnbound));
 };
 
-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>,
+export const runTransaction = <TContract extends AnySqlContract, TIdentifier extends string, A, E, R>(
+	scope: FacadeScope<TContract, TIdentifier>,
+	current: DatabaseExecutor<DefaultModels<TContract>, TContract>,
+	currentFacade: DatabaseService<TContract, TIdentifier>,
 	program: Effect.Effect<A, E, R>,
 	release: typeof releaseTransaction,
 	mode: "test" | "transaction",
 	span: string,
-): Effect.Effect<A, E | PrismaError, Exclude<R, DatabaseIdentifier<Contract, Identifier>>> => {
+): Effect.Effect<A, E | PrismaError, Exclude<R, DatabaseIdentifier<TContract, TIdentifier>>> => {
 	if (!current.liveness.open) {
 		return Effect.fail(toPrismaError({ code: current.liveness.closedCode }));
 	}
@@ -69,7 +69,7 @@ export const runTransaction = <Contract extends AnySqlContract, Identifier exten
 	const transaction = Effect.acquireUseRelease(
 		acquireTransaction(
 			current,
-			(transactionOrm) => namespaceModels<Contract, DefaultModels<Contract>>(current.client.contract, transactionOrm),
+			(transactionOrm) => namespaceModels<TContract, DefaultModels<TContract>>(current.client.contract, transactionOrm),
 			mode,
 		),
 		(resource) => {
@@ -88,11 +88,11 @@ export const runTransaction = <Contract extends AnySqlContract, Identifier exten
 	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>;
+export function makeFacade<TContract extends AnySqlContract, TIdentifier extends string>(
+	scope: FacadeScope<TContract, TIdentifier>,
+	current: DatabaseExecutor<DefaultModels<TContract>, TContract>,
+): DatabaseService<TContract, TIdentifier> {
+	let facade: DatabaseService<TContract, TIdentifier>;
 	const resolveActiveTransaction = Effect.flatMap(scope.activeTransaction, (active) => {
 		if (current.mode === "root") {
 			return Effect.succeed(active ?? { executor: current, facade });
@@ -110,7 +110,7 @@ export function makeFacade<Contract extends AnySqlContract, Identifier extends s
 	);
 	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)) =>
+		transaction: <A, E, R>(program: Effect.Effect<A, E, R> & (DatabaseIdentifier<TContract, TIdentifier> extends R ? unknown : never)) =>
 			Effect.suspend(() => {
 				if (!current.liveness.open) {
 					return Effect.fail(toPrismaError({ code: current.liveness.closedCode }));
@@ -120,7 +120,7 @@ export function makeFacade<Contract extends AnySqlContract, Identifier extends s
 				);
 			}),
 	});
-	facade = databaseFacade<Contract, Identifier>(
+	facade = databaseFacade<TContract, TIdentifier>(
 		new Proxy(target, {
 			get(target, property, receiver) {
 				if (Reflect.has(target, property)) {

package/src/internal/database-factory.ts

@@ -1,6 +1,4 @@
 import { Context, Effect, Layer } from "effect";
-import type { PrismaError } from "#error.ts";
-import { type ActiveTransaction, type FacadeScope, makeFacade, runTransaction } from "./database-facade.ts";
 import {
 	type DatabaseIdentifier,
 	type DatabaseIdentifierLiteral,
@@ -8,38 +6,40 @@ import {
 	type DefaultModels,
 	internalContextIdentifierPrefix,
 	type SqlDatabase,
-} from "./database-types.ts";
+} from "#databaseTypes.ts";
+import type { PrismaError } from "#error.ts";
+import { type ActiveTransaction, type FacadeScope, makeFacade, runTransaction } from "./database-facade.ts";
 import type { AnySqlContract, DatabaseExecutor } from "./executor.ts";
 import { DatabaseTestingTypeId } from "./testing.ts";
 import { releaseTestTransaction } from "./transaction.ts";
 
 let activeTransactionReferenceSequence = 0;
 
-export const makeSqlDatabase = <const Contract extends AnySqlContract, const Identifier extends string, Options>(
-	identifier: DatabaseIdentifierLiteral<Identifier>,
-	acquireExecutor: (options: Options) => Effect.Effect<DatabaseExecutor<DefaultModels<Contract>, Contract>, PrismaError>,
-): SqlDatabase<Contract, Identifier, Options> => {
+export const makeSqlDatabase = <const TContract extends AnySqlContract, const TIdentifier extends string, TOptions>(
+	identifier: DatabaseIdentifierLiteral<TIdentifier>,
+	acquireExecutor: (options: TOptions) => Effect.Effect<DatabaseExecutor<DefaultModels<TContract>, TContract>, PrismaError>,
+): SqlDatabase<TContract, TIdentifier, TOptions> => {
 	if (identifier.startsWith(internalContextIdentifierPrefix)) {
 		throw new TypeError("Database identifier uses a reserved internal namespace");
 	}
-	type Models = DefaultModels<Contract>;
-	type DatabaseId = DatabaseIdentifier<Contract, Identifier>;
+	type Models = DefaultModels<TContract>;
+	type DatabaseId = DatabaseIdentifier<TContract, TIdentifier>;
 
-	const Service = Context.Service<DatabaseId, DatabaseService<Contract, Identifier>>(identifier);
-	const scope: FacadeScope<Contract, Identifier> = {
-		activeTransaction: Context.Reference<ActiveTransaction<Contract, Identifier> | undefined>(
+	const Service = Context.Service<DatabaseId, DatabaseService<TContract, TIdentifier>>(identifier);
+	const scope: FacadeScope<TContract, TIdentifier> = {
+		activeTransaction: Context.Reference<ActiveTransaction<TContract, TIdentifier> | undefined>(
 			`${internalContextIdentifierPrefix}ActiveTransaction/${activeTransactionReferenceSequence++}`,
 			{ defaultValue: () => undefined },
 		),
 		executors: new WeakMap(),
 		service: Service,
 	};
-	const executorOf = (facade: DatabaseService<Contract, Identifier>): Effect.Effect<DatabaseExecutor<Models, Contract>> => {
+	function executorOf(facade: DatabaseService<TContract, TIdentifier>): Effect.Effect<DatabaseExecutor<Models, TContract>> {
 		const executor = scope.executors.get(facade);
 		return executor === undefined
 			? Effect.die(new TypeError("The database service was not created by its database Layer"))
 			: Effect.succeed(executor);
-	};
+	}
 
 	const withTestTransaction = <A, E, R>(
 		program: Effect.Effect<A, E, R> & (DatabaseId extends R ? unknown : never),
@@ -50,7 +50,7 @@ export const makeSqlDatabase = <const Contract extends AnySqlContract, const Ide
 			),
 		);
 
-	const layer = (layerOptions: Options): Layer.Layer<DatabaseId, PrismaError> => {
+	const layer = (layerOptions: TOptions): Layer.Layer<DatabaseId, PrismaError> => {
 		const acquire = Effect.acquireRelease(
 			Effect.suspend(() => acquireExecutor(layerOptions)),
 			(executor) => {

package/src/internal/dynamic.ts

@@ -1,4 +1,6 @@
-const isObjectLike = (value: unknown): value is object => (typeof value === "object" && value !== null) || typeof value === "function";
+function isObjectLike(value: unknown): value is object {
+	return (typeof value === "object" && value !== null) || typeof value === "function";
+}
 
 export const hasMethod = (value: unknown, name: PropertyKey): value is object =>
 	isObjectLike(value) && typeof Reflect.get(value, name) === "function";

package/src/internal/executor.ts

@@ -6,22 +6,22 @@ import type { Semaphore } from "effect";
 export type AnySqlContract = PrismaContract<SqlStorage>;
 export type AnyPostgresContract = AnySqlContract;
 
-export interface SqlDatabaseClient<Contract extends AnySqlContract> {
+export interface SqlDatabaseClient<TContract extends AnySqlContract> {
 	close: () => Promise<void>;
-	readonly context: ExecutionContext<Contract>;
-	readonly contract: Contract;
+	readonly context: ExecutionContext<TContract>;
+	readonly contract: TContract;
 	runtime: () => Runtime;
 }
 
-export interface DatabaseExecutor<Models extends object, Contract extends AnySqlContract = AnySqlContract> {
-	readonly client: SqlDatabaseClient<Contract>;
+export interface DatabaseExecutor<TModels extends object, TContract extends AnySqlContract = AnySqlContract> {
+	readonly client: SqlDatabaseClient<TContract>;
 	readonly identity: object;
 	readonly liveness: {
 		readonly closedCode: string;
 		open: boolean;
 	};
 	readonly mode: "root" | "test" | "transaction";
-	readonly models: Models;
+	readonly models: TModels;
 	readonly querySemaphore: Semaphore.Semaphore | undefined;
 	readonly transactionIdentity: object | undefined;
 	readonly transactionSemaphore: Semaphore.Semaphore | undefined;

package/src/internal/recipe.ts

@@ -23,7 +23,7 @@ export const appendOperation = (parent: RelationRecipe, name: PropertyKey, argum
 	parent,
 });
 
-const operations = (recipe: RelationRecipe): readonly RelationOperation[] => {
+function operations(recipe: RelationRecipe): readonly RelationOperation[] {
 	const reversed: RelationOperation[] = [];
 	let current: RelationRecipe | undefined = recipe;
 
@@ -35,16 +35,16 @@ const operations = (recipe: RelationRecipe): readonly RelationOperation[] => {
 	}
 
 	return reversed.reverse();
-};
+}
 
-const applyMethod = (current: unknown, name: PropertyKey, arguments_: readonly unknown[], model: string): unknown => {
+function applyMethod(current: unknown, name: PropertyKey, arguments_: readonly unknown[], model: string): unknown {
 	if (!hasMethod(current, name)) {
 		throw new TypeError(`Cannot call ${String(name)} while replaying ${model}`);
 	}
 	return invokeMethod(current, name, arguments_);
-};
+}
 
-const replayPlan = (collection: unknown, plan: RelationPlan, owner: object, transactionIdentity: object | undefined): unknown => {
+function replayPlan(collection: unknown, plan: RelationPlan, owner: object, transactionIdentity: object | undefined): unknown {
 	if (!plan.liveness.open) {
 		throw new TypeError("Included Relation is closed");
 	}
@@ -64,9 +64,9 @@ const replayPlan = (collection: unknown, plan: RelationPlan, owner: object, tran
 		return refined;
 	}
 	return applyMethod(refined, "count", [], plan.recipe.model);
-};
+}
 
-const includeRefinement = (value: unknown, owner: object, transactionIdentity: object | undefined): ((collection: unknown) => unknown) => {
+function includeRefinement(value: unknown, owner: object, transactionIdentity: object | undefined): (collection: unknown) => unknown {
 	const plan = getRelationPlan(value);
 	if (plan !== undefined) {
 		return (collection) => replayPlan(collection, plan, owner, transactionIdentity);
@@ -97,9 +97,9 @@ const includeRefinement = (value: unknown, owner: object, transactionIdentity: o
 		const branches = Object.fromEntries(plans.map(([name, queryPlan]) => [name, replayPlan(collection, queryPlan, owner, transactionIdentity)]));
 		return applyMethod(collection, "combine", [branches], model ?? "relation");
 	};
-};
+}
 
-const replayRecipeFrom = (root: unknown, recipe: RelationRecipe, owner: object, transactionIdentity: object | undefined): unknown => {
+function replayRecipeFrom(root: unknown, recipe: RelationRecipe, owner: object, transactionIdentity: object | undefined): unknown {
 	let current = root;
 	for (const operation of operations(recipe)) {
 		const arguments_ =
@@ -109,7 +109,7 @@ const replayRecipeFrom = (root: unknown, recipe: RelationRecipe, owner: object,
 		current = applyMethod(current, operation.name, arguments_, recipe.model);
 	}
 	return current;
-};
+}
 
 export const replayRecipe = (models: object, recipe: RelationRecipe, owner: object, transactionIdentity: object | undefined): unknown => {
 	const current: unknown = Reflect.get(models, recipe.model);