@shivaedev/effect-prisma 0.6.3 → 0.6.4

package/src/relation/include-metadata.ts

@@ -8,46 +8,26 @@ type RelationDefinition<
 	Contract extends AnyPostgresContract,
 	Model extends string,
 	RelationName extends string,
-> = RelationName extends keyof RelationsOf<Contract, Model>
-	? RelationsOf<Contract, Model>[RelationName]
-	: never;
+> = RelationName extends keyof RelationsOf<Contract, Model> ? RelationsOf<Contract, Model>[RelationName] : never;
 
-type RelationCardinalityOf<
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	RelationName extends string,
-> =
+type RelationCardinalityOf<Contract extends AnyPostgresContract, Model extends string, RelationName extends string> =
 	RelationDefinition<Contract, Model, RelationName> extends {
 		readonly cardinality: infer Cardinality extends string;
 	}
 		? Cardinality
 		: never;
 
-export type IsToManyRelation<
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	RelationName extends string,
-> =
-	RelationCardinalityOf<Contract, Model, RelationName> extends "1:N" | "N:M"
-		? true
-		: false;
+export type IsToManyRelation<Contract extends AnyPostgresContract, Model extends string, RelationName extends string> =
+	RelationCardinalityOf<Contract, Model, RelationName> extends "1:N" | "N:M" ? true : false;
 
-export type RelatedModelNameOf<
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	RelationName extends string,
-> =
+export type RelatedModelNameOf<Contract extends AnyPostgresContract, Model extends string, RelationName extends string> =
 	RelationDefinition<Contract, Model, RelationName> extends {
 		readonly to: { readonly model: infer Related extends string };
 	}
 		? Related
 		: never;
 
-type RelationLocalFields<
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	RelationName extends string,
-> =
+type RelationLocalFields<Contract extends AnyPostgresContract, Model extends string, RelationName extends string> =
 	RelationDefinition<Contract, Model, RelationName> extends {
 		readonly on: {
 			readonly localFields: infer Fields extends readonly string[];
@@ -56,8 +36,7 @@ type RelationLocalFields<
 		? Fields
 		: readonly [];
 
-type DefaultNamespace<Contract extends AnyPostgresContract> =
-	Contract["domain"]["namespaces"][keyof Contract["domain"]["namespaces"]];
+type DefaultNamespace<Contract extends AnyPostgresContract> = Contract["domain"]["namespaces"][keyof Contract["domain"]["namespaces"]];
 
 type ModelFields<Contract extends AnyPostgresContract, Model extends string> =
 	DefaultNamespace<Contract> extends {
@@ -70,10 +49,7 @@ type ModelFields<Contract extends AnyPostgresContract, Model extends string> =
 			: never
 		: never;
 
-type AnyNullableField<
-	Fields,
-	Names extends readonly string[],
-> = Names extends readonly [
+type AnyNullableField<Fields, Names extends readonly string[]> = Names extends readonly [
 	infer Head extends string,
 	...infer Tail extends readonly string[],
 ]
@@ -84,19 +60,11 @@ type AnyNullableField<
 		: true
 	: false;
 
-export type IncludedRelationValue<
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	RelationName extends string,
-	Value,
-> =
+export type IncludedRelationValue<Contract extends AnyPostgresContract, Model extends string, RelationName extends string, Value> =
 	RelationCardinalityOf<Contract, Model, RelationName> extends "1:N" | "N:M"
 		? Array<Value>
 		: RelationCardinalityOf<Contract, Model, RelationName> extends "N:1"
-			? AnyNullableField<
-					ModelFields<Contract, Model>,
-					RelationLocalFields<Contract, Model, RelationName>
-				> extends true
+			? AnyNullableField<ModelFields<Contract, Model>, RelationLocalFields<Contract, Model, RelationName>> extends true
 				? Value | null
 				: Value
 			: Value | null;

package/src/relation/include.ts

@@ -1,40 +1,13 @@
-import type {
-	DefaultModelRow,
-	Collection as PrismaCollection,
-	RelationNames,
-} from "@prisma-next/sql-orm-client";
-import type { Relation, RelationQuery } from "../relation.js";
-import type {
-	AnyPostgresContract,
-	IncludedRelationValue,
-	IsToManyRelation,
-	RelatedModelNameOf,
-} from "./include-metadata.js";
+import type { DefaultModelRow, Collection as PrismaCollection, RelationNames } from "@prisma-next/sql-orm-client";
+import type { Relation, RelationQuery } from "../relation.ts";
+import type { AnyPostgresContract, IncludedRelationValue, IsToManyRelation, RelatedModelNameOf } from "./include-metadata.ts";
 
 type Simplify<Value> = { [Key in keyof Value]: Value[Key] };
 
-type QueryValue<Query> =
-	Query extends RelationQuery<
-		infer Value,
-		infer _Contract,
-		infer _Model,
-		infer _DatabaseId
-	>
-		? Value
-		: never;
+type QueryValue<Query> = Query extends RelationQuery<infer Value, infer _Contract, infer _Model, infer _DatabaseId> ? Value : never;
 
-type AcceptRelatedQuery<
-	Query,
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	DatabaseId,
-> = [Query] extends [
-	RelationQuery<
-		infer _Value,
-		infer QueryContract,
-		infer QueryModel,
-		infer QueryDatabaseId
-	>,
+type AcceptRelatedQuery<Query, Contract extends AnyPostgresContract, Model extends string, DatabaseId> = [Query] extends [
+	RelationQuery<infer _Value, infer QueryContract, infer QueryModel, infer QueryDatabaseId>,
 ]
 	? [QueryContract] extends [Contract]
 		? [Contract] extends [QueryContract]
@@ -49,15 +22,8 @@ type AcceptRelatedQuery<
 		: never
 	: never;
 
-type IncludedQueryValue<
-	Query,
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	RelationName extends string,
-> =
-	QueryValue<Query> extends ReadonlyArray<infer Row>
-		? IncludedRelationValue<Contract, Model, RelationName, Row>
-		: QueryValue<Query>;
+type IncludedQueryValue<Query, Contract extends AnyPostgresContract, Model extends string, RelationName extends string> =
+	QueryValue<Query> extends ReadonlyArray<infer Row> ? IncludedRelationValue<Contract, Model, RelationName, Row> : QueryValue<Query>;
 
 type QueryShapeValue<Shape extends Readonly<Record<string, unknown>>> = {
 	readonly [Key in keyof Shape]: QueryValue<Shape[Key]>;
@@ -69,38 +35,16 @@ type AcceptRelatedQueryShape<
 	Model extends string,
 	DatabaseId,
 > = {
-	readonly [Key in keyof Shape]: Shape[Key] &
-		AcceptRelatedQuery<Shape[Key], Contract, Model, DatabaseId>;
+	readonly [Key in keyof Shape]: Shape[Key] & AcceptRelatedQuery<Shape[Key], Contract, Model, DatabaseId>;
 };
 
-type WithIncludedRelation<
-	Collection,
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	RelationName extends string,
-	Value,
-> =
+type WithIncludedRelation<Collection, Contract extends AnyPostgresContract, Model extends string, RelationName extends string, Value> =
 	Collection extends PrismaCollection<Contract, Model, infer Row, infer State>
-		? PrismaCollection<
-				Contract,
-				Model,
-				Simplify<Row & { readonly [Key in RelationName]: Value }>,
-				State
-			>
+		? PrismaCollection<Contract, Model, Simplify<Row & { readonly [Key in RelationName]: Value }>, State>
 		: never;
 
-export type IncludeMethod<
-	Collection,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = Contract extends AnyPostgresContract
-	? Collection extends PrismaCollection<
-			Contract,
-			Model,
-			infer _Row,
-			infer _State
-		>
+export type IncludeMethod<Collection, Contract, Model extends string, DatabaseId> = Contract extends AnyPostgresContract
+	? Collection extends PrismaCollection<Contract, Model, infer _Row, infer _State>
 		? {
 				include<RelationName extends RelationNames<Contract, Model>>(
 					relationName: RelationName,
@@ -110,15 +54,7 @@ export type IncludeMethod<
 						Contract,
 						Model,
 						RelationName,
-						IncludedRelationValue<
-							Contract,
-							Model,
-							RelationName,
-							DefaultModelRow<
-								Contract,
-								RelatedModelNameOf<Contract, Model, RelationName>
-							>
-						>
+						IncludedRelationValue<Contract, Model, RelationName, DefaultModelRow<Contract, RelatedModelNameOf<Contract, Model, RelationName>>>
 					>,
 					Contract,
 					Model,
@@ -126,53 +62,21 @@ export type IncludeMethod<
 				>;
 				include<RelationName extends RelationNames<Contract, Model>, Query>(
 					relationName: RelationName,
-					query: Query &
-						AcceptRelatedQuery<
-							Query,
-							Contract,
-							RelatedModelNameOf<Contract, Model, RelationName>,
-							DatabaseId
-						>,
+					query: Query & AcceptRelatedQuery<Query, Contract, RelatedModelNameOf<Contract, Model, RelationName>, DatabaseId>,
 				): Relation<
-					WithIncludedRelation<
-						Collection,
-						Contract,
-						Model,
-						RelationName,
-						IncludedQueryValue<Query, Contract, Model, RelationName>
-					>,
+					WithIncludedRelation<Collection, Contract, Model, RelationName, IncludedQueryValue<Query, Contract, Model, RelationName>>,
 					Contract,
 					Model,
 					DatabaseId
 				>;
-				include<
-					RelationName extends RelationNames<Contract, Model>,
-					Shape extends Readonly<Record<string, unknown>>,
-				>(
+				include<RelationName extends RelationNames<Contract, Model>, Shape extends Readonly<Record<string, unknown>>>(
 					relationName: RelationName,
 					shape: IsToManyRelation<Contract, Model, RelationName> extends true
 						? keyof Shape extends never
 							? never
-							: Shape &
-									AcceptRelatedQueryShape<
-										Shape,
-										Contract,
-										RelatedModelNameOf<Contract, Model, RelationName>,
-										DatabaseId
-									>
+							: Shape & AcceptRelatedQueryShape<Shape, Contract, RelatedModelNameOf<Contract, Model, RelationName>, DatabaseId>
 						: never,
-				): Relation<
-					WithIncludedRelation<
-						Collection,
-						Contract,
-						Model,
-						RelationName,
-						QueryShapeValue<Shape>
-					>,
-					Contract,
-					Model,
-					DatabaseId
-				>;
+				): Relation<WithIncludedRelation<Collection, Contract, Model, RelationName, QueryShapeValue<Shape>>, Contract, Model, DatabaseId>;
 			}
 		: Record<never, never>
 	: Record<never, never>;

package/src/relation/prisma-methods.ts

@@ -9,57 +9,31 @@ import type {
 	Collection as PrismaCollection,
 } from "@prisma-next/sql-orm-client";
 import type { Effect, Stream } from "effect";
-import type { PrismaError } from "../error.js";
-import type { CollectionResult, Relation, RelationQuery } from "../relation.js";
-import type { IncludeMethod } from "./include.js";
+import type { PrismaError } from "../error.ts";
+import type { CollectionResult, Relation, RelationQuery } from "../relation.ts";
+import type { IncludeMethod } from "./include.ts";
 
 type AnyFunction = (...arguments_: ReadonlyArray<never>) => unknown;
 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> = Method extends (
-	...arguments_: infer Arguments
-) => PromiseLike<infer Value>
+type TerminalMethod<Method> = Method extends (...arguments_: infer Arguments) => PromiseLike<infer Value>
 	? (...arguments_: Arguments) => Effect.Effect<Awaited<Value>, PrismaError>
 	: never;
 
-type SelectMethod<
-	Collection,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = Contract extends AnyPostgresContract
-	? Collection extends PrismaCollection<
-			Contract,
-			Model,
-			infer _Row,
-			infer State
-		>
+type SelectMethod<Collection, Contract, Model extends string, DatabaseId> = Contract extends AnyPostgresContract
+	? Collection extends PrismaCollection<Contract, Model, infer _Row, infer State>
 		? {
 				select<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
 					...fields: Fields
-				): Relation<
-					PrismaCollection<
-						Contract,
-						Model,
-						Pick<DefaultModelRow<Contract, Model>, Fields[number]>,
-						State
-					>,
-					Contract,
-					Model,
-					DatabaseId
-				>;
+				): Relation<PrismaCollection<Contract, Model, Pick<DefaultModelRow<Contract, Model>, Fields[number]>, State>, Contract, Model, DatabaseId>;
 			}
 		: Record<never, never>
 	: Collection extends { select: infer Select extends AnyFunction }
 		? {
 				select: Select extends (...arguments_: infer Arguments) => infer Result
-					? (
-							...arguments_: Arguments
-						) => Result extends object
-							? Relation<Result, Contract, Model, DatabaseId>
-							: never
+					? (...arguments_: Arguments) => Result extends object ? Relation<Result, Contract, Model, DatabaseId> : never
 					: never;
 			}
 		: Record<never, never>;
@@ -70,102 +44,45 @@ type AggregateConfigure<Collection> = Collection extends {
 	? Exclude<Parameters<Method>[1], undefined>
 	: never;
 
-type AggregateSuccess<
-	Collection,
-	Contract extends AnyPostgresContract,
-	Model extends string,
-	Spec extends AggregateSpec,
-> =
-	Collection extends GroupedCollection<
-		Contract,
-		Model,
-		infer Fields extends FieldTuple<DefaultModelRow<Contract, Model>>
-	>
-		? Array<
-				Simplify<
-					Pick<DefaultModelRow<Contract, Model>, Fields[number]> &
-						AggregateResult<Spec>
-				>
-			>
+type AggregateSuccess<Collection, Contract extends AnyPostgresContract, Model extends string, Spec extends AggregateSpec> =
+	Collection extends GroupedCollection<Contract, Model, infer Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>
+		? Array<Simplify<Pick<DefaultModelRow<Contract, Model>, Fields[number]> & AggregateResult<Spec>>>
 		: AggregateResult<Spec>;
 
-type AggregateMethod<
-	Collection,
-	Contract,
-	Model extends string,
-> = Contract extends AnyPostgresContract
+type AggregateMethod<Collection, Contract, Model extends string> = Contract extends AnyPostgresContract
 	? Collection extends { aggregate: AnyFunction }
 		? {
 				aggregate<Spec extends AggregateSpec>(
 					make: (aggregate: AggregateBuilder<Contract, Model>) => Spec,
 					configure?: AggregateConfigure<Collection>,
-				): Effect.Effect<
-					AggregateSuccess<Collection, Contract, Model, Spec>,
-					PrismaError
-				>;
+				): Effect.Effect<AggregateSuccess<Collection, Contract, Model, Spec>, PrismaError>;
 			}
 		: Record<never, never>
 	: Record<never, never>;
 
-type CollectionMethods<
-	Collection,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = Contract extends AnyPostgresContract
-	? Collection extends PrismaCollection<
-			Contract,
-			Model,
-			infer _Row,
-			infer State
-		>
+type CollectionMethods<Collection, Contract, Model extends string, DatabaseId> = Contract extends AnyPostgresContract
+	? Collection extends PrismaCollection<Contract, Model, infer _Row, infer State>
 		? {
 				groupBy<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
 					...fields: Fields
-				): Relation<
-					GroupedCollection<Contract, Model, Fields>,
-					Contract,
-					Model,
-					DatabaseId
-				>;
+				): Relation<GroupedCollection<Contract, Model, Fields>, Contract, Model, DatabaseId>;
 				cursor(
-					values: State extends { readonly hasOrderBy: true }
-						? Partial<
-								Record<keyof DefaultModelRow<Contract, Model> & string, unknown>
-							>
-						: never,
-				): Relation<Collection, Contract, Model, DatabaseId>;
-				distinct<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
-					...fields: Fields
+					values: State extends { readonly hasOrderBy: true } ? Partial<Record<keyof DefaultModelRow<Contract, Model> & string, unknown>> : never,
 				): Relation<Collection, Contract, Model, DatabaseId>;
+				distinct<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(...fields: Fields): Relation<Collection, Contract, Model, DatabaseId>;
 				distinctOn<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
-					...fields: State extends { readonly hasOrderBy: true }
-						? Fields
-						: never
+					...fields: State extends { readonly hasOrderBy: true } ? Fields : never
 				): Relation<Collection, Contract, Model, DatabaseId>;
 			} & (State extends { readonly hasWhere: true }
 				? {
-						readonly [Key in
-							| "delete"
-							| "deleteAll"
-							| "deleteCount"]: TerminalMethod<Collection[Key]>;
+						readonly [Key in "delete" | "deleteAll" | "deleteCount"]: TerminalMethod<Collection[Key]>;
 					}
 				: Record<never, never>)
 		: Record<never, never>
 	: Record<never, never>;
 
-type CollectionConveniences<
-	Collection,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = Contract extends AnyPostgresContract
-	? Collection extends PrismaCollection<
-			Contract,
-			Model,
-			infer Row,
-			infer _State
-		>
+type CollectionConveniences<Collection, Contract, Model extends string, DatabaseId> = Contract extends AnyPostgresContract
+	? Collection extends PrismaCollection<Contract, Model, infer Row, infer _State>
 		? {
 				readonly stream: Stream.Stream<Row, PrismaError>;
 				count(): RelationQuery<number, Contract, Model, DatabaseId>;
@@ -180,12 +97,7 @@ type CollectionConveniences<
 			}
 		: Record<never, never>;
 
-export type PrismaRelationMethods<
-	Collection,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = SelectMethod<Collection, Contract, Model, DatabaseId> &
+export type PrismaRelationMethods<Collection, Contract, Model extends string, DatabaseId> = SelectMethod<Collection, Contract, Model, DatabaseId> &
 	IncludeMethod<Collection, Contract, Model, DatabaseId> &
 	AggregateMethod<Collection, Contract, Model> &
 	CollectionMethods<Collection, Contract, Model, DatabaseId> &

package/src/relation.ts

@@ -1,6 +1,6 @@
 import type { Effect } from "effect";
-import type { PrismaError } from "./error.js";
-import type { PrismaRelationMethods } from "./relation/prisma-methods.js";
+import type { PrismaError } from "./error.ts";
+import type { PrismaRelationMethods } from "./relation/prisma-methods.ts";
 
 type AnyFunction = (...arguments_: ReadonlyArray<never>) => unknown;
 
@@ -10,9 +10,7 @@ export type CollectionResult<Collection> = Collection extends {
 	? Awaited<Result>
 	: never;
 
-type NormalizeTerminal<Name, Result> = Name extends "first"
-	? import("effect").Option.Option<Exclude<Result, null>>
-	: Result;
+type NormalizeTerminal<Name, Result> = Name extends "first" ? import("effect").Option.Option<Exclude<Result, null>> : Result;
 
 type WrapReturn<Name, Result, Contract, Model extends string, DatabaseId> =
 	Result extends PromiseLike<infer Value>
@@ -21,13 +19,7 @@ type WrapReturn<Name, Result, Contract, Model extends string, DatabaseId> =
 			? Relation<Result, Contract, Model, DatabaseId>
 			: never;
 
-type WrapFunction<
-	Name,
-	Function_,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = Function_ extends {
+type WrapFunction<Name, Function_, Contract, Model extends string, DatabaseId> = Function_ extends {
 	(...arguments_: infer Arguments1): infer Result1;
 	(...arguments_: infer Arguments2): infer Result2;
 	(...arguments_: infer Arguments3): infer Result3;
@@ -35,24 +27,12 @@ type WrapFunction<
 	(...arguments_: infer Arguments5): infer Result5;
 	(...arguments_: infer Arguments6): infer Result6;
 }
-	? ((
-			...arguments_: Arguments1
-		) => WrapReturn<Name, Result1, Contract, Model, DatabaseId>) &
-			((
-				...arguments_: Arguments2
-			) => WrapReturn<Name, Result2, Contract, Model, DatabaseId>) &
-			((
-				...arguments_: Arguments3
-			) => WrapReturn<Name, Result3, Contract, Model, DatabaseId>) &
-			((
-				...arguments_: Arguments4
-			) => WrapReturn<Name, Result4, Contract, Model, DatabaseId>) &
-			((
-				...arguments_: Arguments5
-			) => WrapReturn<Name, Result5, Contract, Model, DatabaseId>) &
-			((
-				...arguments_: Arguments6
-			) => WrapReturn<Name, Result6, Contract, Model, DatabaseId>)
+	? ((...arguments_: Arguments1) => WrapReturn<Name, Result1, Contract, Model, DatabaseId>) &
+			((...arguments_: Arguments2) => WrapReturn<Name, Result2, Contract, Model, DatabaseId>) &
+			((...arguments_: Arguments3) => WrapReturn<Name, Result3, Contract, Model, DatabaseId>) &
+			((...arguments_: Arguments4) => WrapReturn<Name, Result4, Contract, Model, DatabaseId>) &
+			((...arguments_: Arguments5) => WrapReturn<Name, Result5, Contract, Model, DatabaseId>) &
+			((...arguments_: Arguments6) => WrapReturn<Name, Result6, Contract, Model, DatabaseId>)
 	: never;
 
 type FunctionKeys<Value> = {
@@ -79,20 +59,12 @@ type ExplicitPrismaMethod =
 	| "variant";
 
 type RelationMethods<Collection, Contract, Model extends string, DatabaseId> = {
-	readonly [Key in Exclude<
-		FunctionKeys<Collection>,
-		ExplicitPrismaMethod
-	>]: WrapFunction<Key, Collection[Key], Contract, Model, DatabaseId>;
+	readonly [Key in Exclude<FunctionKeys<Collection>, ExplicitPrismaMethod>]: WrapFunction<Key, Collection[Key], Contract, Model, DatabaseId>;
 };
 
 declare const RelationQueryTypeId: unique symbol;
 
-export type RelationQuery<
-	Value,
-	Contract,
-	Model extends string,
-	DatabaseId,
-> = Effect.Effect<Value, PrismaError> & {
+export type RelationQuery<Value, Contract, Model extends string, DatabaseId> = Effect.Effect<Value, PrismaError> & {
 	readonly [RelationQueryTypeId]: {
 		readonly contract: Contract;
 		readonly database: (database: DatabaseId) => DatabaseId;
@@ -100,11 +72,11 @@ export type RelationQuery<
 	};
 };
 
-export type Relation<
-	Collection,
-	Contract = undefined,
-	Model extends string = string,
-	DatabaseId = undefined,
-> = RelationQuery<CollectionResult<Collection>, Contract, Model, DatabaseId> &
+export type Relation<Collection, Contract = undefined, Model extends string = string, DatabaseId = undefined> = RelationQuery<
+	CollectionResult<Collection>,
+	Contract,
+	Model,
+	DatabaseId
+> &
 	RelationMethods<Collection, Contract, Model, DatabaseId> &
 	PrismaRelationMethods<Collection, Contract, Model, DatabaseId>;