@shivaedev/effect-prisma 0.6.4 → 0.7.0

package/src/relation/include.ts

@@ -43,40 +43,42 @@ type WithIncludedRelation<Collection, Contract extends AnyPostgresContract, Mode
 		? PrismaCollection<Contract, Model, Simplify<Row & { readonly [Key in RelationName]: Value }>, State>
 		: never;
 
+interface IncludeOverloads<Collection, Contract extends AnyPostgresContract, Model extends string, DatabaseId> {
+	<RelationName extends RelationNames<Contract, Model>>(
+		relationName: RelationName,
+	): Relation<
+		WithIncludedRelation<
+			Collection,
+			Contract,
+			Model,
+			RelationName,
+			IncludedRelationValue<Contract, Model, RelationName, DefaultModelRow<Contract, RelatedModelNameOf<Contract, Model, RelationName>>>
+		>,
+		Contract,
+		Model,
+		DatabaseId
+	>;
+	<RelationName extends RelationNames<Contract, Model>, Query>(
+		relationName: RelationName,
+		query: Query & AcceptRelatedQuery<Query, Contract, RelatedModelNameOf<Contract, Model, RelationName>, DatabaseId>,
+	): Relation<
+		WithIncludedRelation<Collection, Contract, Model, RelationName, IncludedQueryValue<Query, Contract, Model, RelationName>>,
+		Contract,
+		Model,
+		DatabaseId
+	>;
+	<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>
+			: never,
+	): Relation<WithIncludedRelation<Collection, Contract, Model, RelationName, QueryShapeValue<Shape>>, Contract, Model, DatabaseId>;
+}
+
 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,
-				): Relation<
-					WithIncludedRelation<
-						Collection,
-						Contract,
-						Model,
-						RelationName,
-						IncludedRelationValue<Contract, Model, RelationName, DefaultModelRow<Contract, RelatedModelNameOf<Contract, Model, RelationName>>>
-					>,
-					Contract,
-					Model,
-					DatabaseId
-				>;
-				include<RelationName extends RelationNames<Contract, Model>, Query>(
-					relationName: RelationName,
-					query: Query & AcceptRelatedQuery<Query, Contract, RelatedModelNameOf<Contract, Model, RelationName>, DatabaseId>,
-				): Relation<
-					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>>>(
-					relationName: RelationName,
-					shape: IsToManyRelation<Contract, Model, RelationName> extends true
-						? keyof Shape extends never
-							? never
-							: Shape & AcceptRelatedQueryShape<Shape, Contract, RelatedModelNameOf<Contract, Model, RelationName>, DatabaseId>
-						: never,
-				): Relation<WithIncludedRelation<Collection, Contract, Model, RelationName, QueryShapeValue<Shape>>, Contract, Model, DatabaseId>;
-			}
+		? { include: IncludeOverloads<Collection, Contract, Model, DatabaseId> }
 		: Record<never, never>
 	: Record<never, never>;

package/src/relation/prisma-methods.ts

@@ -13,7 +13,7 @@ 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 AnyFunction = (...arguments_: readonly 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] };
@@ -25,9 +25,9 @@ type TerminalMethod<Method> = Method extends (...arguments_: infer Arguments) =>
 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>>>(
+				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 }
@@ -46,16 +46,16 @@ type AggregateConfigure<Collection> = Collection extends {
 
 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>>>
+		? Simplify<Pick<DefaultModelRow<Contract, Model>, Fields[number]> & AggregateResult<Spec>>[]
 		: AggregateResult<Spec>;
 
 type AggregateMethod<Collection, Contract, Model extends string> = Contract extends AnyPostgresContract
 	? Collection extends { aggregate: AnyFunction }
 		? {
-				aggregate<Spec extends AggregateSpec>(
+				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>;
@@ -63,16 +63,18 @@ type AggregateMethod<Collection, Contract, Model extends string> = Contract exte
 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>>>(
+				groupBy: <Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
 					...fields: Fields
-				): Relation<GroupedCollection<Contract, Model, Fields>, Contract, Model, DatabaseId>;
-				cursor(
+				) => 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): Relation<Collection, Contract, Model, DatabaseId>;
-				distinctOn<Fields extends FieldTuple<DefaultModelRow<Contract, Model>>>(
+				) => 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
-				): Relation<Collection, Contract, Model, DatabaseId>;
+				) => Relation<Collection, Contract, Model, DatabaseId>;
 			} & (State extends { readonly hasWhere: true }
 				? {
 						readonly [Key in "delete" | "deleteAll" | "deleteCount"]: TerminalMethod<Collection[Key]>;
@@ -85,15 +87,15 @@ type CollectionConveniences<Collection, Contract, Model extends string, Database
 	? Collection extends PrismaCollection<Contract, Model, infer Row, infer _State>
 		? {
 				readonly stream: Stream.Stream<Row, PrismaError>;
-				count(): RelationQuery<number, Contract, Model, DatabaseId>;
-				exists(): Effect.Effect<boolean, 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>;
-				count(): Effect.Effect<number, PrismaError>;
-				exists(): Effect.Effect<boolean, PrismaError>;
+				count: () => Effect.Effect<number, PrismaError>;
+				exists: () => Effect.Effect<boolean, PrismaError>;
 			}
 		: Record<never, never>;
 

package/src/relation.ts

@@ -2,10 +2,10 @@ import type { Effect } from "effect";
 import type { PrismaError } from "./error.ts";
 import type { PrismaRelationMethods } from "./relation/prisma-methods.ts";
 
-type AnyFunction = (...arguments_: ReadonlyArray<never>) => unknown;
+type AnyFunction = (...arguments_: readonly never[]) => unknown;
 
 export type CollectionResult<Collection> = Collection extends {
-	all(): infer Result;
+	all: () => infer Result;
 }
 	? Awaited<Result>
 	: never;

package/src/sqlite.ts

@@ -10,16 +10,11 @@ import { fromPrismaPromise } from "./internal/promise.ts";
 import { decodeSqliteDatetimesAsUtc } from "./internal/sqlite-datetime.ts";
 import { applySqlitePragmas, assertFileBackedPath } from "./internal/sqlite-pragmas.ts";
 
-export const defaultSqlitePragmas: ReadonlyArray<string> = ["journal_mode=WAL"];
+export const defaultSqlitePragmas: readonly string[] = ["journal_mode=WAL"];
 
 export interface SqliteDatabaseLayerOptions extends SqliteOptionsBase {
-	/** Path to the database file. In-memory databases are not supported. */
 	readonly path: string;
-	/**
-	 * Pragmas applied once when the Layer connects. Defaults to
-	 * {@link defaultSqlitePragmas}; pass `[]` to skip them.
-	 */
-	readonly pragmas?: ReadonlyArray<string>;
+	readonly pragmas?: readonly string[];
 }
 
 type SqliteFactoryOptions<Contract extends AnySqlContract> =

package/src/testing/types.ts

@@ -1,6 +1,6 @@
 import type { TestContext, Vitest } from "@effect/vitest";
-import type { EffectClock, EffectTestOptions } from "@shivaedev/effect-test";
 import type { Effect, Layer } from "effect";
+import type { EffectClock, EffectTestOptions } from "@shivaedev/effect-test";
 import type { AnyDatabase, DatabaseServiceOf } from "../database.ts";
 
 export type { AnyDatabase } from "../database.ts";
@@ -13,18 +13,18 @@ export type DatabaseTest<Database extends AnyDatabase, Provided> = <A, Eff exten
 ) => void;
 
 export interface DatabaseTester<Database extends AnyDatabase, Provided> extends DatabaseTest<Database, Provided> {
-	readonly skip: DatabaseTest<Database, Provided>;
-	readonly skipIf: (condition: unknown) => DatabaseTest<Database, Provided>;
-	readonly runIf: (condition: unknown) => DatabaseTest<Database, Provided>;
-	readonly only: DatabaseTest<Database, Provided>;
 	readonly each: <Item>(
-		cases: ReadonlyArray<Item>,
+		cases: readonly Item[],
 	) => <A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
 		name: string,
 		body: (item: Item, database: DatabaseService<Database>, context: TestContext) => Generator<Eff, A, never>,
 		options?: number | EffectTestOptions,
 	) => void;
 	readonly fails: DatabaseTest<Database, Provided>;
+	readonly only: DatabaseTest<Database, Provided>;
+	readonly runIf: (condition: unknown) => DatabaseTest<Database, Provided>;
+	readonly skip: DatabaseTest<Database, Provided>;
+	readonly skipIf: (condition: unknown) => DatabaseTest<Database, Provided>;
 }
 
 export type DatabaseIt<Database extends AnyDatabase, Provided> = Vitest.Methods & {

package/src/testing/vitest.ts

@@ -1,6 +1,6 @@
 import { it as effectIt } from "@effect/vitest";
-import { type EffectClock, makeEffectIt } from "@shivaedev/effect-test";
 import type { Effect, Layer } from "effect";
+import { type EffectClock, makeEffectIt } from "@shivaedev/effect-test";
 import { withTestTransaction } from "./transaction.ts";
 import type { AnyDatabase, DatabaseIt, MakeDatabaseItOptions } from "./types.ts";