@shivaedev/effect-prisma 0.5.3 → 0.6.0

package/src/relation/prisma-methods.ts

@@ -18,19 +18,17 @@ type AnyPostgresContract = PrismaContract<SqlStorage>;
 type FieldTuple<Row> = readonly [keyof Row & string, ...(keyof Row & string)[]];
 type Simplify<Value> = { [Key in keyof Value]: Value[Key] };
 
-type TerminalMethod<Method, Requirement> = Method extends (
+type TerminalMethod<Method> = Method extends (
 	...arguments_: infer Arguments
 ) => PromiseLike<infer Value>
-	? (
-			...arguments_: Arguments
-		) => Effect.Effect<Awaited<Value>, PrismaError, Requirement>
+	? (...arguments_: Arguments) => Effect.Effect<Awaited<Value>, PrismaError>
 	: never;
 
 type SelectMethod<
 	Collection,
-	Requirement,
 	Contract,
 	Model extends string,
+	DatabaseId,
 > = Contract extends AnyPostgresContract
 	? Collection extends PrismaCollection<
 			Contract,
@@ -48,9 +46,9 @@ type SelectMethod<
 						Pick<DefaultModelRow<Contract, Model>, Fields[number]>,
 						State
 					>,
-					Requirement,
 					Contract,
-					Model
+					Model,
+					DatabaseId
 				>;
 			}
 		: Record<never, never>
@@ -60,7 +58,7 @@ type SelectMethod<
 					? (
 							...arguments_: Arguments
 						) => Result extends object
-							? Relation<Result, Requirement, Contract, Model>
+							? Relation<Result, Contract, Model, DatabaseId>
 							: never
 					: never;
 			}
@@ -93,7 +91,6 @@ type AggregateSuccess<
 
 type AggregateMethod<
 	Collection,
-	Requirement,
 	Contract,
 	Model extends string,
 > = Contract extends AnyPostgresContract
@@ -104,8 +101,7 @@ type AggregateMethod<
 					configure?: AggregateConfigure<Collection>,
 				): Effect.Effect<
 					AggregateSuccess<Collection, Contract, Model, Spec>,
-					PrismaError,
-					Requirement
+					PrismaError
 				>;
 			}
 		: Record<never, never>
@@ -113,9 +109,9 @@ type AggregateMethod<
 
 type CollectionMethods<
 	Collection,
-	Requirement,
 	Contract,
 	Model extends string,
+	DatabaseId,
 > = Contract extends AnyPostgresContract
 	? Collection extends PrismaCollection<
 			Contract,
@@ -128,9 +124,9 @@ type CollectionMethods<
 					...fields: Fields
 				): Relation<
 					GroupedCollection<Contract, Model, Fields>,
-					Requirement,
 					Contract,
-					Model
+					Model,
+					DatabaseId
 				>;
 				cursor(
 					values: State extends { readonly hasOrderBy: true }
@@ -138,21 +134,21 @@ type CollectionMethods<
 								Record<keyof DefaultModelRow<Contract, Model> & string, unknown>
 							>
 						: never,
-				): Relation<Collection, Requirement, Contract, Model>;
+				): Relation<Collection, Contract, Model, DatabaseId>;
 				distinct<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
 					...fields: Fields
-				): Relation<Collection, Requirement, Contract, Model>;
+				): Relation<Collection, Contract, Model, DatabaseId>;
 				distinctOn<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
 					...fields: State extends { readonly hasOrderBy: true }
 						? Fields
 						: never
-				): Relation<Collection, Requirement, Contract, Model>;
+				): Relation<Collection, Contract, Model, DatabaseId>;
 			} & (State extends { readonly hasWhere: true }
 				? {
 						readonly [Key in
 							| "delete"
 							| "deleteAll"
-							| "deleteCount"]: TerminalMethod<Collection[Key], Requirement>;
+							| "deleteCount"]: TerminalMethod<Collection[Key]>;
 					}
 				: Record<never, never>)
 		: Record<never, never>
@@ -160,9 +156,9 @@ type CollectionMethods<
 
 type CollectionConveniences<
 	Collection,
-	Requirement,
 	Contract,
 	Model extends string,
+	DatabaseId,
 > = Contract extends AnyPostgresContract
 	? Collection extends PrismaCollection<
 			Contract,
@@ -171,26 +167,26 @@ type CollectionConveniences<
 			infer _State
 		>
 		? {
-				readonly stream: Stream.Stream<Row, PrismaError, Requirement>;
-				count(): RelationQuery<number, Requirement, Contract, Model>;
-				exists(): Effect.Effect<boolean, PrismaError, Requirement>;
+				readonly stream: Stream.Stream<Row, PrismaError>;
+				count(): RelationQuery<number, Contract, Model, DatabaseId>;
+				exists(): Effect.Effect<boolean, PrismaError>;
 			}
 		: Record<never, never>
 	: CollectionResult<Collection> extends ReadonlyArray<infer Row>
 		? {
-				readonly stream: Stream.Stream<Row, PrismaError, Requirement>;
-				count(): Effect.Effect<number, PrismaError, Requirement>;
-				exists(): Effect.Effect<boolean, PrismaError, Requirement>;
+				readonly stream: Stream.Stream<Row, PrismaError>;
+				count(): Effect.Effect<number, PrismaError>;
+				exists(): Effect.Effect<boolean, PrismaError>;
 			}
 		: Record<never, never>;
 
 export type PrismaRelationMethods<
 	Collection,
-	Requirement,
 	Contract,
 	Model extends string,
-> = SelectMethod<Collection, Requirement, Contract, Model> &
-	IncludeMethod<Collection, Requirement, Contract, Model> &
-	AggregateMethod<Collection, Requirement, Contract, Model> &
-	CollectionMethods<Collection, Requirement, Contract, Model> &
-	CollectionConveniences<Collection, Requirement, Contract, Model>;
+	DatabaseId,
+> = SelectMethod<Collection, Contract, Model, DatabaseId> &
+	IncludeMethod<Collection, Contract, Model, DatabaseId> &
+	AggregateMethod<Collection, Contract, Model> &
+	CollectionMethods<Collection, Contract, Model, DatabaseId> &
+	CollectionConveniences<Collection, Contract, Model, DatabaseId>;

package/src/relation.ts

@@ -14,23 +14,19 @@ type NormalizeTerminal<Name, Result> = Name extends "first"
 	? import("effect").Option.Option<Exclude<Result, null>>
 	: Result;
 
-type WrapReturn<Name, Result, Requirement, Contract, Model extends string> =
+type WrapReturn<Name, Result, Contract, Model extends string, DatabaseId> =
 	Result extends PromiseLike<infer Value>
-		? Effect.Effect<
-				NormalizeTerminal<Name, Awaited<Value>>,
-				PrismaError,
-				Requirement
-			>
+		? Effect.Effect<NormalizeTerminal<Name, Awaited<Value>>, PrismaError>
 		: Result extends object
-			? Relation<Result, Requirement, Contract, Model>
+			? Relation<Result, Contract, Model, DatabaseId>
 			: never;
 
 type WrapFunction<
 	Name,
 	Function_,
-	Requirement,
 	Contract,
 	Model extends string,
+	DatabaseId,
 > = Function_ extends {
 	(...arguments_: infer Arguments1): infer Result1;
 	(...arguments_: infer Arguments2): infer Result2;
@@ -41,22 +37,22 @@ type WrapFunction<
 }
 	? ((
 			...arguments_: Arguments1
-		) => WrapReturn<Name, Result1, Requirement, Contract, Model>) &
+		) => WrapReturn<Name, Result1, Contract, Model, DatabaseId>) &
 			((
 				...arguments_: Arguments2
-			) => WrapReturn<Name, Result2, Requirement, Contract, Model>) &
+			) => WrapReturn<Name, Result2, Contract, Model, DatabaseId>) &
 			((
 				...arguments_: Arguments3
-			) => WrapReturn<Name, Result3, Requirement, Contract, Model>) &
+			) => WrapReturn<Name, Result3, Contract, Model, DatabaseId>) &
 			((
 				...arguments_: Arguments4
-			) => WrapReturn<Name, Result4, Requirement, Contract, Model>) &
+			) => WrapReturn<Name, Result4, Contract, Model, DatabaseId>) &
 			((
 				...arguments_: Arguments5
-			) => WrapReturn<Name, Result5, Requirement, Contract, Model>) &
+			) => WrapReturn<Name, Result5, Contract, Model, DatabaseId>) &
 			((
 				...arguments_: Arguments6
-			) => WrapReturn<Name, Result6, Requirement, Contract, Model>)
+			) => WrapReturn<Name, Result6, Contract, Model, DatabaseId>)
 	: never;
 
 type FunctionKeys<Value> = {
@@ -82,37 +78,33 @@ type ExplicitPrismaMethod =
 	| "sum"
 	| "variant";
 
-type RelationMethods<
-	Collection,
-	Requirement,
-	Contract,
-	Model extends string,
-> = {
+type RelationMethods<Collection, Contract, Model extends string, DatabaseId> = {
 	readonly [Key in Exclude<
 		FunctionKeys<Collection>,
 		ExplicitPrismaMethod
-	>]: WrapFunction<Key, Collection[Key], Requirement, Contract, Model>;
+	>]: WrapFunction<Key, Collection[Key], Contract, Model, DatabaseId>;
 };
 
 declare const RelationQueryTypeId: unique symbol;
 
 export type RelationQuery<
 	Value,
-	Requirement,
 	Contract,
 	Model extends string,
-> = Effect.Effect<Value, PrismaError, Requirement> & {
+	DatabaseId,
+> = Effect.Effect<Value, PrismaError> & {
 	readonly [RelationQueryTypeId]: {
 		readonly contract: Contract;
+		readonly database: (database: DatabaseId) => DatabaseId;
 		readonly model: Model;
 	};
 };
 
 export type Relation<
 	Collection,
-	Requirement,
 	Contract = undefined,
 	Model extends string = string,
-> = RelationQuery<CollectionResult<Collection>, Requirement, Contract, Model> &
-	RelationMethods<Collection, Requirement, Contract, Model> &
-	PrismaRelationMethods<Collection, Requirement, Contract, Model>;
+	DatabaseId = undefined,
+> = RelationQuery<CollectionResult<Collection>, Contract, Model, DatabaseId> &
+	RelationMethods<Collection, Contract, Model, DatabaseId> &
+	PrismaRelationMethods<Collection, Contract, Model, DatabaseId>;

package/src/sqlite.ts

@@ -2,7 +2,7 @@ import sqlite, {
 	type SqliteClient,
 	type SqliteOptionsBase,
 } from "@prisma-next/sqlite/runtime";
-import type { Layer } from "effect";
+import { type Layer, Semaphore } from "effect";
 import type { PrismaError } from "./error.js";
 import {
 	acquireConnectedClient,
@@ -10,14 +10,12 @@ import {
 } from "./internal/client-lifecycle.js";
 import {
 	type DatabaseIdentifier,
+	type DatabaseIdentifierLiteral,
 	type DatabaseServiceHolder,
 	type DefaultModels,
 	makeSqlDatabase,
 } from "./internal/database-factory.js";
-import type {
-	AnySqlContract,
-	ExecutorIdentifier,
-} from "./internal/executor.js";
+import type { AnySqlContract } from "./internal/executor.js";
 import { fromPrismaPromise } from "./internal/promise.js";
 import { decodeSqliteDatetimesAsUtc } from "./internal/sqlite-datetime.js";
 import {
@@ -49,60 +47,69 @@ type SqliteFactoryOptions<Contract extends AnySqlContract> =
 
 export interface SqliteDatabaseDefinition<
 	Contract extends AnySqlContract,
-	Requirement = ExecutorIdentifier<DefaultModels<Contract>>,
-> extends DatabaseServiceHolder<Contract, Requirement> {
+	Identifier extends string,
+> extends DatabaseServiceHolder<Contract, Identifier> {
 	readonly layer: (
 		options: SqliteDatabaseLayerOptions,
-	) => Layer.Layer<DatabaseIdentifier<Contract> | Requirement, PrismaError>;
+	) => Layer.Layer<DatabaseIdentifier<Contract, Identifier>, PrismaError>;
 }
 
-export const makeSqliteDatabase = <const Contract extends AnySqlContract>(
-	identifier: string,
-	options: SqliteFactoryOptions<Contract>,
-): SqliteDatabaseDefinition<Contract> => {
-	type Models = DefaultModels<Contract>;
+export const makeSqliteDatabase =
+	<const Contract extends AnySqlContract>() =>
+	<const Identifier extends string>(
+		identifier: DatabaseIdentifierLiteral<Identifier>,
+		options: SqliteFactoryOptions<Contract>,
+	): SqliteDatabaseDefinition<Contract, Identifier> => {
+		type Models = DefaultModels<Contract>;
 
-	return makeSqlDatabase<Contract, SqliteDatabaseLayerOptions>(
-		identifier,
-		(layerOptions) => {
-			assertFileBackedPath(layerOptions.path);
-			applySqlitePragmas(
-				layerOptions.path,
-				layerOptions.pragmas ?? defaultSqlitePragmas,
-			);
+		return makeSqlDatabase<Contract, Identifier, SqliteDatabaseLayerOptions>(
+			identifier,
+			(layerOptions) => {
+				assertFileBackedPath(layerOptions.path);
+				applySqlitePragmas(
+					layerOptions.path,
+					layerOptions.pragmas ?? defaultSqlitePragmas,
+				);
 
-			const clientOptions = {
-				path: layerOptions.path,
-				extensions: layerOptions.extensions,
-				middleware: layerOptions.middleware,
-				verifyMarker: layerOptions.verifyMarker,
-			};
-			const client: SqliteClient<Contract> =
-				options.contract === undefined
-					? sqlite<Contract>({
-							...clientOptions,
-							contractJson: options.contractJson,
-						})
-					: sqlite<Contract>({
-							...clientOptions,
-							contract: options.contract,
-						});
+				const clientOptions = {
+					path: layerOptions.path,
+					extensions: layerOptions.extensions,
+					middleware: layerOptions.middleware,
+					verifyMarker: layerOptions.verifyMarker,
+				};
+				const client: SqliteClient<Contract> =
+					options.contract === undefined
+						? sqlite<Contract>({
+								...clientOptions,
+								contractJson: options.contractJson,
+							})
+						: sqlite<Contract>({
+								...clientOptions,
+								contract: options.contract,
+							});
 
-			decodeSqliteDatetimesAsUtc(client.context);
+				decodeSqliteDatetimesAsUtc(client.context);
 
-			return fromPrismaPromise(() =>
-				acquireConnectedClient(client, () => {
-					// The SQLite client already exposes the unbound namespace.
-					const models = client.orm as Models;
-					assertAvailableModelNames(Object.keys(models));
-					return {
-						client,
-						models,
-						querySemaphore: undefined,
-						transactional: false,
-					};
-				}),
-			);
-		},
-	) as SqliteDatabaseDefinition<Contract>;
-};
+				return fromPrismaPromise(() =>
+					acquireConnectedClient(client, () => {
+						// The SQLite client already exposes the unbound namespace.
+						const models = client.orm as Models;
+						assertAvailableModelNames(Object.keys(models));
+						return {
+							client,
+							identity: {},
+							liveness: {
+								closedCode: "RUNTIME.DATABASE_CLOSED",
+								open: true,
+							},
+							mode: "root",
+							models,
+							querySemaphore: undefined,
+							transactionIdentity: undefined,
+							transactionSemaphore: Semaphore.makeUnsafe(1),
+						};
+					}),
+				);
+			},
+		) as SqliteDatabaseDefinition<Contract, Identifier>;
+	};

package/src/testing/transaction.ts

@@ -1,18 +1,28 @@
 import type { Effect } from "effect";
 import type { PrismaError } from "../error.js";
 import { getDatabaseTesting } from "../internal/testing.js";
-import type { AnyDatabase, DatabaseRequirement } from "./types.js";
+import type { AnyDatabase } from "./types.js";
 
 type WithTestTransaction = {
 	<Database extends AnyDatabase>(
 		database: Database,
 	): <A, E, R>(
-		program: Effect.Effect<A, E, R>,
-	) => Effect.Effect<A, E | PrismaError, R | DatabaseRequirement<Database>>;
+		program: Effect.Effect<A, E, R> &
+			(Effect.Services<Database> extends R ? unknown : never),
+	) => Effect.Effect<
+		A,
+		E | PrismaError,
+		Effect.Services<Database> | Exclude<R, Effect.Services<Database>>
+	>;
 	<Database extends AnyDatabase, A, E, R>(
 		database: Database,
-		program: Effect.Effect<A, E, R>,
-	): Effect.Effect<A, E | PrismaError, R | DatabaseRequirement<Database>>;
+		program: Effect.Effect<A, E, R> &
+			(Effect.Services<Database> extends R ? unknown : never),
+	): Effect.Effect<
+		A,
+		E | PrismaError,
+		Effect.Services<Database> | Exclude<R, Effect.Services<Database>>
+	>;
 };
 
 export const withTestTransaction: WithTestTransaction = ((
@@ -20,7 +30,7 @@ export const withTestTransaction: WithTestTransaction = ((
 	program?: Effect.Effect<unknown, unknown, unknown>,
 ) => {
 	const run = (effect: Effect.Effect<unknown, unknown, unknown>) =>
-		getDatabaseTesting<DatabaseRequirement<typeof database>>(
+		getDatabaseTesting<Effect.Services<typeof database>>(
 			database,
 		).withTestTransaction(effect);
 

package/src/testing/types.ts

@@ -2,7 +2,7 @@ import type { TestContext, TestOptions, Vitest } from "@effect/vitest";
 import type { Effect, Layer } from "effect";
 import type { AnyDatabase, DatabaseServiceOf } from "../database.js";
 
-export type { AnyDatabase, DatabaseRequirement } from "../database.js";
+export type { AnyDatabase } from "../database.js";
 export type DatabaseService<Database extends AnyDatabase> =
 	DatabaseServiceOf<Database>;
 

package/src/testing/vitest.ts

@@ -8,7 +8,6 @@ import {
 import type {
 	AnyDatabase,
 	DatabaseIt,
-	DatabaseRequirement,
 	MakeDatabaseItOptions,
 } from "./types.js";
 
@@ -19,18 +18,12 @@ export const makeDatabaseIt = <
 >(
 	options: MakeDatabaseItOptions<Database, Provided, LayerError> & {
 		readonly layer: Layer.Layer<
-			Provided | DatabaseRequirement<Database> | Effect.Services<Database>,
+			Provided | Effect.Services<Database>,
 			LayerError
 		>;
 	},
-): DatabaseIt<
-	Database,
-	Provided | DatabaseRequirement<Database> | Effect.Services<Database>
-> => {
-	type Services =
-		| Provided
-		| DatabaseRequirement<Database>
-		| Effect.Services<Database>;
+): DatabaseIt<Database, Provided | Effect.Services<Database>> => {
+	type Services = Provided | Effect.Services<Database>;
 
 	const fixtureIt = effectIt.extend(
 		fixtureName,

package/src/testing.ts

@@ -2,7 +2,6 @@ export { withTestTransaction } from "./testing/transaction.js";
 export type {
 	AnyDatabase,
 	DatabaseIt,
-	DatabaseRequirement,
 	DatabaseService,
 	DatabaseTest,
 	DatabaseTester,