@shivaedev/effect-prisma 0.1.0 → 0.3.0

package/src/relation/include-metadata.ts

@@ -0,0 +1,102 @@
+import type { Contract as PrismaContract } from "@prisma-next/contract/types";
+import type { SqlStorage } from "@prisma-next/sql-contract/types";
+import type { RelationsOf } from "@prisma-next/sql-orm-client";
+
+export type AnyPostgresContract = PrismaContract<SqlStorage>;
+
+type RelationDefinition<
+	Contract extends AnyPostgresContract,
+	Model extends string,
+	RelationName extends string,
+> = RelationName extends keyof RelationsOf<Contract, Model>
+	? RelationsOf<Contract, Model>[RelationName]
+	: never;
+
+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 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,
+> =
+	RelationDefinition<Contract, Model, RelationName> extends {
+		readonly on: {
+			readonly localFields: infer Fields extends readonly string[];
+		};
+	}
+		? Fields
+		: readonly [];
+
+type DefaultNamespace<Contract extends AnyPostgresContract> =
+	Contract["domain"]["namespaces"][keyof Contract["domain"]["namespaces"]];
+
+type ModelFields<Contract extends AnyPostgresContract, Model extends string> =
+	DefaultNamespace<Contract> extends {
+		readonly models: infer Models;
+	}
+		? Model extends keyof Models
+			? Models[Model] extends { readonly fields: infer Fields }
+				? Fields
+				: never
+			: never
+		: never;
+
+type AnyNullableField<
+	Fields,
+	Names extends readonly string[],
+> = Names extends readonly [
+	infer Head extends string,
+	...infer Tail extends readonly string[],
+]
+	? Head extends keyof Fields
+		? Fields[Head] extends { readonly nullable: true }
+			? true
+			: AnyNullableField<Fields, Tail>
+		: true
+	: false;
+
+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
+				? Value | null
+				: Value
+			: Value | null;

package/src/relation/include.ts

@@ -0,0 +1,169 @@
+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";
+
+type Simplify<Value> = { [Key in keyof Value]: Value[Key] };
+
+type QueryValue<Query> =
+	Query extends RelationQuery<
+		infer Value,
+		infer _Requirement,
+		infer _Contract,
+		infer _Model
+	>
+		? Value
+		: never;
+
+type AcceptRelatedQuery<
+	Query,
+	Contract extends AnyPostgresContract,
+	Model extends string,
+> =
+	Query extends RelationQuery<
+		infer _Value,
+		infer _Requirement,
+		infer QueryContract,
+		infer QueryModel
+	>
+		? [QueryContract] extends [Contract]
+			? [Contract] extends [QueryContract]
+				? QueryModel extends Model
+					? unknown
+					: never
+				: never
+			: 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 QueryShapeValue<Shape extends Readonly<Record<string, unknown>>> = {
+	readonly [Key in keyof Shape]: QueryValue<Shape[Key]>;
+};
+
+type AcceptRelatedQueryShape<
+	Shape extends Readonly<Record<string, unknown>>,
+	Contract extends AnyPostgresContract,
+	Model extends string,
+> = {
+	readonly [Key in keyof Shape]: Shape[Key] &
+		AcceptRelatedQuery<Shape[Key], Contract, Model>;
+};
+
+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
+			>
+		: never;
+
+export type IncludeMethod<
+	Collection,
+	Requirement,
+	Contract,
+	Model extends string,
+> = Contract extends AnyPostgresContract
+	? Collection extends PrismaCollection<
+			Contract,
+			Model,
+			infer _Row,
+			infer _State
+		>
+		? {
+				include<RelationName extends RelationNames<Contract, Model>>(
+					relationName: RelationName,
+				): Relation<
+					WithIncludedRelation<
+						Collection,
+						Contract,
+						Model,
+						RelationName,
+						IncludedRelationValue<
+							Contract,
+							Model,
+							RelationName,
+							DefaultModelRow<
+								Contract,
+								RelatedModelNameOf<Contract, Model, RelationName>
+							>
+						>
+					>,
+					Requirement,
+					Contract,
+					Model
+				>;
+				include<RelationName extends RelationNames<Contract, Model>, Query>(
+					relationName: RelationName,
+					query: Query &
+						AcceptRelatedQuery<
+							Query,
+							Contract,
+							RelatedModelNameOf<Contract, Model, RelationName>
+						>,
+				): Relation<
+					WithIncludedRelation<
+						Collection,
+						Contract,
+						Model,
+						RelationName,
+						IncludedQueryValue<Query, Contract, Model, RelationName>
+					>,
+					Requirement,
+					Contract,
+					Model
+				>;
+				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>
+									>
+						: never,
+				): Relation<
+					WithIncludedRelation<
+						Collection,
+						Contract,
+						Model,
+						RelationName,
+						QueryShapeValue<Shape>
+					>,
+					Requirement,
+					Contract,
+					Model
+				>;
+			}
+		: Record<never, never>
+	: Record<never, never>;

package/src/relation/prisma-methods.ts

@@ -10,7 +10,8 @@ import type {
 } from "@prisma-next/sql-orm-client";
 import type { Effect, Stream } from "effect";
 import type { PrismaError } from "../error.js";
-import type { CollectionResult, Relation } from "../relation.js";
+import type { CollectionResult, Relation, RelationQuery } from "../relation.js";
+import type { IncludeMethod } from "./include.js";
 
 type AnyFunction = (...arguments_: ReadonlyArray<never>) => unknown;
 type AnyPostgresContract = PrismaContract<SqlStorage>;
@@ -171,12 +172,14 @@ type CollectionConveniences<
 		>
 		? {
 				readonly stream: Stream.Stream<Row, PrismaError, Requirement>;
+				count(): RelationQuery<number, Requirement, Contract, Model>;
 				exists(): Effect.Effect<boolean, PrismaError, Requirement>;
 			}
 		: 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>;
 			}
 		: Record<never, never>;
@@ -187,6 +190,7 @@ export type PrismaRelationMethods<
 	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>;

package/src/relation.ts

@@ -94,11 +94,25 @@ type RelationMethods<
 	>]: WrapFunction<Key, Collection[Key], Requirement, Contract, Model>;
 };
 
+declare const RelationQueryTypeId: unique symbol;
+
+export type RelationQuery<
+	Value,
+	Requirement,
+	Contract,
+	Model extends string,
+> = Effect.Effect<Value, PrismaError, Requirement> & {
+	readonly [RelationQueryTypeId]: {
+		readonly contract: Contract;
+		readonly model: Model;
+	};
+};
+
 export type Relation<
 	Collection,
 	Requirement,
 	Contract = undefined,
 	Model extends string = string,
-> = Effect.Effect<CollectionResult<Collection>, PrismaError, Requirement> &
+> = RelationQuery<CollectionResult<Collection>, Requirement, Contract, Model> &
 	RelationMethods<Collection, Requirement, Contract, Model> &
 	PrismaRelationMethods<Collection, Requirement, Contract, Model>;

package/src/testing.ts

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