@shivaedev/effect-trpc 0.3.4 → 0.4.0

package/src/procedure.ts

@@ -1,41 +1,18 @@
-import type {
-	TRPCMutationProcedure,
-	TRPCProcedureBuilder,
-	TRPCQueryProcedure,
-	TRPCSubscriptionProcedure,
-} from "@trpc/server";
+import type { TRPCMutationProcedure, TRPCQueryProcedure, TRPCSubscriptionProcedure } from "@trpc/server";
 import { Schema } from "effect";
-import { makeProcedureHandler } from "./internal/procedure-handler.js";
+import { makeProcedureHandler } from "./internal/procedure-handler.ts";
 import type {
 	DefaultValue,
 	EffectProcedureResolver,
 	EffectSubscriptionResolver,
 	IntersectIfDefined,
+	ProcedureBuilderSurface,
 	ResolverContext,
-} from "./internal/procedure-types.js";
-import type { RuntimeBridge } from "./internal/runtime.js";
-import { captureStackTrace } from "./internal/stack-trace.js";
-import { makeSubscriptionHandler } from "./internal/subscription-handler.js";
-import type { EffectProcedureRequestServices } from "./request-services.js";
-
-type Builder<
-	Context,
-	Meta,
-	ContextOverrides,
-	InputIn,
-	InputOut,
-	OutputIn,
-	OutputOut,
-> = TRPCProcedureBuilder<
-	Context,
-	Meta,
-	ContextOverrides,
-	InputIn,
-	InputOut,
-	OutputIn,
-	OutputOut,
-	false
->;
+} from "./internal/procedure-types.ts";
+import type { RuntimeBridge } from "./internal/runtime.ts";
+import { captureStackTrace } from "./internal/stack-trace.ts";
+import { makeSubscriptionHandler } from "./internal/subscription-handler.ts";
+import type { EffectProcedureRequestServices } from "./request-services.ts";
 
 export class EffectProcedureBuilder<
 	Context,
@@ -50,30 +27,8 @@ export class EffectProcedureBuilder<
 	RuntimeRequirements,
 > {
 	constructor(
-		private readonly builder: Builder<
-			Context,
-			Meta,
-			ContextOverrides,
-			InputIn,
-			InputOut,
-			OutputIn,
-			OutputOut
-		>,
-		private readonly requestServices: EffectProcedureRequestServices<
-			ResolverContext<
-				Builder<
-					Context,
-					Meta,
-					ContextOverrides,
-					InputIn,
-					InputOut,
-					OutputIn,
-					OutputOut
-				>
-			>,
-			ProvidedServices,
-			LayerError
-		>,
+		private readonly builder: ProcedureBuilderSurface<ResolverContext<Context, Meta, ContextOverrides>>,
+		private readonly requestServices: EffectProcedureRequestServices<ResolverContext<Context, Meta, ContextOverrides>, ProvidedServices, LayerError>,
 		private readonly runtime: RuntimeBridge<RuntimeRequirements>,
 		private readonly subscriptionBuilder = builder,
 		private readonly subscriptionOutput?: Schema.ConstraintDecoder<unknown>,
@@ -93,31 +48,12 @@ export class EffectProcedureBuilder<
 		LayerError,
 		RuntimeRequirements
 	> {
-		const next = this.builder.input(Schema.toStandardSchemaV1(schema) as never);
-		const subscriptionNext = this.subscriptionBuilder.input(
-			Schema.toStandardSchemaV1(schema) as never,
-		);
+		const parser = Schema.toStandardSchemaV1(schema);
 		return new EffectProcedureBuilder(
-			next as unknown as Builder<
-				Context,
-				Meta,
-				ContextOverrides,
-				IntersectIfDefined<InputIn, SchemaValue["Encoded"]>,
-				IntersectIfDefined<InputOut, SchemaValue["Type"]>,
-				OutputIn,
-				OutputOut
-			>,
+			this.builder.input(parser),
 			this.requestServices,
 			this.runtime,
-			subscriptionNext as unknown as Builder<
-				Context,
-				Meta,
-				ContextOverrides,
-				IntersectIfDefined<InputIn, SchemaValue["Encoded"]>,
-				IntersectIfDefined<InputOut, SchemaValue["Type"]>,
-				OutputIn,
-				OutputOut
-			>,
+			this.subscriptionBuilder.input(parser),
 			this.subscriptionOutput,
 		);
 	}
@@ -136,28 +72,11 @@ export class EffectProcedureBuilder<
 		LayerError,
 		RuntimeRequirements
 	> {
-		const next = this.builder.output(Schema.toStandardSchemaV1(schema));
 		return new EffectProcedureBuilder(
-			next as unknown as Builder<
-				Context,
-				Meta,
-				ContextOverrides,
-				InputIn,
-				InputOut,
-				IntersectIfDefined<OutputIn, SchemaValue["Encoded"]>,
-				IntersectIfDefined<OutputOut, SchemaValue["Type"]>
-			>,
+			this.builder.output(Schema.toStandardSchemaV1(schema)),
 			this.requestServices,
 			this.runtime,
-			this.subscriptionBuilder as unknown as Builder<
-				Context,
-				Meta,
-				ContextOverrides,
-				InputIn,
-				InputOut,
-				IntersectIfDefined<OutputIn, SchemaValue["Encoded"]>,
-				IntersectIfDefined<OutputOut, SchemaValue["Type"]>
-			>,
+			this.subscriptionBuilder,
 			schema,
 		);
 	}
@@ -172,12 +91,9 @@ export class EffectProcedureBuilder<
 		input: DefaultValue<InputIn, void>;
 		output: DefaultValue<OutputOut, Output>;
 		meta: Meta;
-	}> {
-		return this.dispatch("query", resolver) as TRPCQueryProcedure<{
-			input: DefaultValue<InputIn, void>;
-			output: DefaultValue<OutputOut, Output>;
-			meta: Meta;
-		}>;
+	}>;
+	query(resolver: EffectProcedureResolver<never, ProvidedServices | RuntimeRequirements, unknown>): unknown {
+		return this.builder.query(this.handler("query", resolver));
 	}
 
 	mutation<Output>(
@@ -190,12 +106,9 @@ export class EffectProcedureBuilder<
 		input: DefaultValue<InputIn, void>;
 		output: DefaultValue<OutputOut, Output>;
 		meta: Meta;
-	}> {
-		return this.dispatch("mutation", resolver) as TRPCMutationProcedure<{
-			input: DefaultValue<InputIn, void>;
-			output: DefaultValue<OutputOut, Output>;
-			meta: Meta;
-		}>;
+	}>;
+	mutation(resolver: EffectProcedureResolver<never, ProvidedServices | RuntimeRequirements, unknown>): unknown {
+		return this.builder.mutation(this.handler("mutation", resolver));
 	}
 
 	subscription<Output>(
@@ -208,42 +121,20 @@ export class EffectProcedureBuilder<
 		input: DefaultValue<InputIn, void>;
 		output: AsyncIterable<DefaultValue<OutputOut, Output>, void, unknown>;
 		meta: Meta;
-	}> {
-		const handler = makeSubscriptionHandler(
-			this.runtime,
-			resolver,
-			this.requestServices,
-			{
-				captureStackTrace: captureStackTrace(),
-				type: "subscription",
-			},
-			this.subscriptionOutput,
-		) as never;
+	}>;
+	subscription(resolver: EffectSubscriptionResolver<never, ProvidedServices | RuntimeRequirements, unknown>): unknown {
 		return this.subscriptionBuilder.subscription(
-			handler,
-		) as TRPCSubscriptionProcedure<{
-			input: DefaultValue<InputIn, void>;
-			output: AsyncIterable<DefaultValue<OutputOut, Output>, void, unknown>;
-			meta: Meta;
-		}>;
+			makeSubscriptionHandler(
+				this.runtime,
+				resolver,
+				this.requestServices,
+				{ captureStackTrace: captureStackTrace(), type: "subscription" },
+				this.subscriptionOutput,
+			),
+		);
 	}
 
-	private dispatch<Output>(
-		type: "mutation" | "query",
-		resolver: EffectProcedureResolver<
-			DefaultValue<InputOut, undefined>,
-			ProvidedServices | NoInfer<RuntimeRequirements>,
-			Output
-		>,
-	): unknown {
-		const handler = makeProcedureHandler(
-			this.runtime,
-			resolver,
-			this.requestServices,
-			{ captureStackTrace: captureStackTrace(), type },
-		) as never;
-		return type === "query"
-			? this.builder.query(handler)
-			: this.builder.mutation(handler);
+	private handler(type: "mutation" | "query", resolver: EffectProcedureResolver<never, ProvidedServices | RuntimeRequirements, unknown>) {
+		return makeProcedureHandler(this.runtime, resolver, this.requestServices, { captureStackTrace: captureStackTrace(), type });
 	}
 }

package/src/rejection-formatter.ts

@@ -0,0 +1,29 @@
+import { StandardSchemaV1Error, type TRPCDefaultErrorShape, type TRPCError } from "@trpc/server";
+import type { EncodedRejection } from "./client/rejection.ts";
+import { RejectionError } from "./rejection.ts";
+
+export interface RejectionData {
+	readonly rejection?: EncodedRejection;
+}
+
+export type RejectionErrorShape = TRPCDefaultErrorShape & { readonly data: RejectionData };
+
+const inputRejection = ({ issues: [issue] }: StandardSchemaV1Error): EncodedRejection | undefined => {
+	if (issue === undefined) return undefined;
+	const field = (issue.path ?? []).map((segment) => String(typeof segment === "object" ? segment.key : segment)).join(".");
+	return field === "" ? { _tag: "BadRequest", message: issue.message } : { _tag: "BadRequest", message: issue.message, field };
+};
+
+const rejectionFrom = (error: TRPCError): EncodedRejection | undefined => {
+	if (error instanceof RejectionError) return error.rejection;
+	if (error.code === "BAD_REQUEST" && error.cause instanceof StandardSchemaV1Error) return inputRejection(error.cause);
+	return undefined;
+};
+
+export const withRejection = <Shape extends { readonly data: object }>(shape: Shape, error: TRPCError): Shape & { readonly data: RejectionData } => {
+	const rejection = rejectionFrom(error);
+	return rejection === undefined ? shape : { ...shape, data: { ...shape.data, rejection } };
+};
+
+export const rejectionFormatter = ({ shape, error }: { readonly shape: TRPCDefaultErrorShape; readonly error: TRPCError }): RejectionErrorShape =>
+	withRejection(shape, error);

package/src/rejection.ts

@@ -0,0 +1,47 @@
+import { type TRPC_ERROR_CODE_KEY, TRPCError } from "@trpc/server";
+import { Effect, Schema } from "effect";
+import { EncodedRejection } from "./client/rejection.ts";
+
+const TAXONOMY_CODES = new Map<string, TRPC_ERROR_CODE_KEY>([
+	["NotFound", "NOT_FOUND"],
+	["Unauthorized", "UNAUTHORIZED"],
+	["Forbidden", "FORBIDDEN"],
+	["Conflict", "CONFLICT"],
+	["PreconditionFailed", "PRECONDITION_FAILED"],
+	["AuthUnavailable", "SERVICE_UNAVAILABLE"],
+]);
+
+export const rejectionCode = (tag: string): TRPC_ERROR_CODE_KEY => TAXONOMY_CODES.get(tag) ?? "BAD_REQUEST";
+
+export class RejectionError extends TRPCError {
+	readonly rejection: EncodedRejection;
+
+	constructor(rejection: EncodedRejection, code: TRPC_ERROR_CODE_KEY = rejectionCode(rejection._tag)) {
+		super({ code, message: typeof rejection.message === "string" ? rejection.message : rejection._tag });
+		this.rejection = rejection;
+	}
+}
+
+export interface RejectWithOptions<Tag extends string> {
+	readonly code?: (tag: Tag) => TRPC_ERROR_CODE_KEY;
+}
+
+const encodeRejection = (schema: Schema.Constraint) => {
+	const encode = Schema.encodeUnknownEffect(schema);
+	const tagged = Schema.decodeUnknownEffect(EncodedRejection);
+	return (rejection: unknown) => Effect.orDie(Effect.flatMap(encode(rejection), tagged));
+};
+
+export function rejectWith<S extends Schema.ConstraintDecoder<{ readonly _tag: string }, unknown>>(
+	schema: S,
+	options?: RejectWithOptions<S["Type"]["_tag"]>,
+): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, Exclude<E, S["Type"]> | RejectionError, R | S["EncodingServices"]>;
+export function rejectWith(schema: Schema.Constraint, options?: RejectWithOptions<string>) {
+	const is = Schema.is(schema);
+	const encode = encodeRejection(schema);
+	const code = options?.code ?? rejectionCode;
+	return <A, E, R>(self: Effect.Effect<A, E, R>) =>
+		Effect.catchIf(self, is, (rejection) =>
+			Effect.flatMap(encode(rejection), (encoded) => Effect.fail(new RejectionError(encoded, code(encoded._tag)))),
+		);
+}

package/src/request-services.ts

@@ -1,10 +1,6 @@
 import { type Layer as EffectLayer, Layer } from "effect";
 
-export interface EffectProcedureRequestServices<
-	Context,
-	Requirements,
-	Error = never,
-> {
+export interface EffectProcedureRequestServices<Context, Requirements, Error = never> {
 	readonly layer: (context: Context) => EffectLayer.Layer<Requirements, Error>;
 }
 
@@ -21,23 +17,7 @@ export const extendRequestServices = <
 	AdditionalError,
 	AdditionalDependencies extends BaseRequirements = BaseRequirements,
 >(
-	base: EffectProcedureRequestServices<
-		BaseContext,
-		BaseRequirements,
-		BaseError
-	>,
-	additional: (
-		context: Context,
-	) => EffectLayer.Layer<
-		AdditionalRequirements,
-		AdditionalError,
-		AdditionalDependencies
-	>,
-): EffectProcedureRequestServices<
-	Context,
-	BaseRequirements | AdditionalRequirements,
-	BaseError | AdditionalError
-> =>
-	makeRequestServices((context: Context) =>
-		Layer.provideMerge(additional(context), base.layer(context)),
-	);
+	base: EffectProcedureRequestServices<BaseContext, BaseRequirements, BaseError>,
+	additional: (context: Context) => EffectLayer.Layer<AdditionalRequirements, AdditionalError, AdditionalDependencies>,
+): EffectProcedureRequestServices<Context, BaseRequirements | AdditionalRequirements, BaseError | AdditionalError> =>
+	makeRequestServices((context: Context) => Layer.provideMerge(additional(context), base.layer(context)));

package/src/request-signal.ts

@@ -1,7 +1,4 @@
 import { Context } from "effect";
 
 /** The transport cancellation signal for the current tRPC procedure. */
-export const RequestSignal = Context.Reference<AbortSignal | undefined>(
-	"@shivaedev/effect-trpc/RequestSignal",
-	{ defaultValue: () => undefined },
-);
+export const RequestSignal = Context.Reference<AbortSignal | undefined>("@shivaedev/effect-trpc/RequestSignal", { defaultValue: () => undefined });

package/src/testing/any-test-layer.ts

@@ -0,0 +1,3 @@
+import type { Layer } from "effect";
+
+export type AnyTestLayer = Layer.Layer<any, any, never>;

package/src/testing/caller.ts

@@ -1,11 +1,9 @@
 import { getTRPCErrorFromUnknown, type TRPCError } from "@trpc/server";
 import { type Context, Effect } from "effect";
-import type { EffectTRPCAdapter } from "../adapter.js";
+import type { EffectTRPCAdapter } from "../adapter.ts";
 
 export type EffectCaller<Caller> = {
-	readonly [Key in keyof Caller]: Caller[Key] extends (
-		...arguments_: infer Arguments
-	) => Promise<infer Result>
+	readonly [Key in keyof Caller]: Caller[Key] extends (...arguments_: infer Arguments) => Promise<infer Result>
 		? (...arguments_: Arguments) => Effect.Effect<Result, TRPCError>
 		: Caller[Key] extends (...arguments_: infer Arguments) => infer Result
 			? (...arguments_: Arguments) => Result
@@ -14,14 +12,26 @@ export type EffectCaller<Caller> = {
 				: Caller[Key];
 };
 
-export type EffectCallerFactory<Options, Caller> = EffectCaller<Caller> &
-	((options?: Options) => EffectCaller<Caller>);
+export type EffectCallerFactory<Options, Caller> = EffectCaller<Caller> & ((options?: Options) => EffectCaller<Caller>);
 
-export const makeEffectCaller = <Caller extends object, Services>(
-	adapter: Pick<EffectTRPCAdapter<never>, "runWithServices">,
+type Adapter = Pick<EffectTRPCAdapter<never>, "runWithServices">;
+
+const member = (node: unknown, segment: string): unknown =>
+	(typeof node === "object" && node !== null) || typeof node === "function" ? Reflect.get(node, segment) : undefined;
+
+const invoke = (promiseCaller: object, path: ReadonlyArray<string>, argumentsList: ReadonlyArray<unknown>): Promise<unknown> => {
+	const leaf = path.reduce<unknown>(member, promiseCaller);
+	return typeof leaf === "function"
+		? Promise.resolve(Reflect.apply(leaf, undefined, argumentsList))
+		: Promise.reject(new TypeError(`${path.join(".")} is not a procedure`));
+};
+
+export function makeEffectCaller<Caller extends object, Services>(
+	adapter: Adapter,
 	promiseCaller: Caller,
 	services: Context.Context<Services>,
-): EffectCaller<Caller> => {
+): EffectCaller<Caller>;
+export function makeEffectCaller(adapter: Adapter, promiseCaller: object, services: Context.Context<never>): unknown {
 	const build = (path: ReadonlyArray<string>): unknown =>
 		new Proxy(
 			Object.assign(() => undefined, { path }),
@@ -29,16 +39,7 @@ export const makeEffectCaller = <Caller extends object, Services>(
 				apply(_target, _this, argumentsList) {
 					return Effect.tryPromise({
 						catch: getTRPCErrorFromUnknown,
-						try: () =>
-							adapter.runWithServices(services, () => {
-								let leaf: unknown = promiseCaller;
-								for (const segment of path) {
-									leaf = (leaf as Record<string, unknown>)[segment];
-								}
-								return (leaf as (...args: unknown[]) => Promise<unknown>)(
-									...argumentsList,
-								);
-							}),
+						try: () => adapter.runWithServices(services, () => invoke(promiseCaller, path, argumentsList)),
 					});
 				},
 				get(_target, property) {
@@ -50,21 +51,17 @@ export const makeEffectCaller = <Caller extends object, Services>(
 			},
 		);
 
-	return build([]) as EffectCaller<Caller>;
-};
+	return build([]);
+}
 
-export const makeEffectCallerFactory = <
-	Options,
-	Caller extends object,
-	Services,
->(
-	adapter: Pick<EffectTRPCAdapter<never>, "runWithServices">,
+export function makeEffectCallerFactory<Options, Caller extends object, Services>(
+	adapter: Adapter,
 	createCaller: (options?: Options) => Caller,
 	services: Context.Context<Services>,
-): EffectCallerFactory<Options, Caller> => {
+): EffectCallerFactory<Options, Caller>;
+export function makeEffectCallerFactory(adapter: Adapter, createCaller: (options?: unknown) => object, services: Context.Context<never>): unknown {
 	const defaultCaller = makeEffectCaller(adapter, createCaller(), services);
-	const target = (options?: Options) =>
-		makeEffectCaller(adapter, createCaller(options), services);
+	const target = (options?: unknown) => makeEffectCaller(adapter, createCaller(options), services);
 
 	return new Proxy(target, {
 		get(_target, property, receiver) {
@@ -76,5 +73,5 @@ export const makeEffectCallerFactory = <
 			}
 			return Reflect.get(defaultCaller, property);
 		},
-	}) as EffectCallerFactory<Options, Caller>;
-};
+	});
+}

package/src/testing/types.ts

@@ -1,20 +1,17 @@
 import type { TestContext, Vitest } from "@effect/vitest";
 import type { EffectClock, EffectTestOptions } from "@shivaedev/effect-test";
 import type { Effect, Layer } from "effect";
-import type { EffectTRPCAdapter } from "../adapter.js";
-import type { EffectCallerFactory } from "./caller.js";
+import type { EffectTRPCAdapter } from "../adapter.ts";
+import type { AnyTestLayer } from "./any-test-layer.ts";
+import type { EffectCallerFactory } from "./caller.ts";
 
-export type TrpcHarnessTest<Harness, Provided> = <
-	A,
-	Eff extends Effect.Effect<unknown, unknown, Provided>,
->(
+export type TrpcHarnessTest<Harness, Provided> = <A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
 	name: string,
 	body: (harness: Harness, context: TestContext) => Generator<Eff, A, never>,
 	options?: number | EffectTestOptions,
 ) => void;
 
-export interface TrpcHarnessTester<Harness, Provided>
-	extends TrpcHarnessTest<Harness, Provided> {
+export interface TrpcHarnessTester<Harness, Provided> extends TrpcHarnessTest<Harness, Provided> {
 	readonly skip: TrpcHarnessTest<Harness, Provided>;
 	readonly skipIf: (condition: unknown) => TrpcHarnessTest<Harness, Provided>;
 	readonly runIf: (condition: unknown) => TrpcHarnessTest<Harness, Provided>;
@@ -23,25 +20,15 @@ export interface TrpcHarnessTester<Harness, Provided>
 		cases: ReadonlyArray<Item>,
 	) => <A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
 		name: string,
-		body: (
-			item: Item,
-			harness: Harness,
-			context: TestContext,
-		) => Generator<Eff, A, never>,
+		body: (item: Item, harness: Harness, context: TestContext) => Generator<Eff, A, never>,
 		options?: number | EffectTestOptions,
 	) => void;
 	readonly fails: TrpcHarnessTest<Harness, Provided>;
 }
 
-export type TrpcTest<Options, Caller, Provided> = TrpcHarnessTest<
-	EffectCallerFactory<Options, Caller>,
-	Provided
->;
+export type TrpcTest<Options, Caller, Provided> = TrpcHarnessTest<EffectCallerFactory<Options, Caller>, Provided>;
 
-export type TrpcTester<Options, Caller, Provided> = TrpcHarnessTester<
-	EffectCallerFactory<Options, Caller>,
-	Provided
->;
+export type TrpcTester<Options, Caller, Provided> = TrpcHarnessTester<EffectCallerFactory<Options, Caller>, Provided>;
 
 export type TrpcIt<Options, Caller, Provided> = Vitest.Methods & {
 	readonly effectTRPC: TrpcTester<Options, Caller, Provided>;
@@ -51,44 +38,25 @@ export type TrpcHarnessIt<Harness, Provided> = Vitest.Methods & {
 	readonly effectTRPC: TrpcHarnessTester<Harness, Provided>;
 };
 
-export interface MakeTrpcItOptions<
-	CreateCaller extends (...arguments_: never[]) => object,
-	// biome-ignore lint/suspicious/noExplicitAny: Layer output and error are recovered with Layer utility types
-	TestLayer extends Layer.Layer<any, any, never>,
-> {
+export interface MakeTrpcItOptions<CreateCaller extends (...arguments_: never[]) => object, TestLayer extends AnyTestLayer> {
 	readonly adapter: Pick<EffectTRPCAdapter<never>, "runWithServices">;
-	readonly around?: <A, E>(
-		effect: Effect.Effect<A, E, Layer.Success<TestLayer>>,
-	) => Effect.Effect<A, unknown, Layer.Success<TestLayer>>;
+	readonly around?: <A, E>(effect: Effect.Effect<A, E, Layer.Success<TestLayer>>) => Effect.Effect<A, unknown, Layer.Success<TestLayer>>;
 	readonly clock?: EffectClock;
 	readonly createCaller: CreateCaller;
 	readonly layer: TestLayer;
 }
 
-export interface MakeTrpcHarnessItOptions<
-	CreateCaller extends (...arguments_: never[]) => object,
-	// biome-ignore lint/suspicious/noExplicitAny: Layer output and error are recovered with Layer utility types
-	TestLayer extends Layer.Layer<any, any, never>,
-	Harness,
-> extends MakeTrpcItOptions<CreateCaller, TestLayer> {
+export interface MakeTrpcHarnessItOptions<CreateCaller extends (...arguments_: never[]) => object, TestLayer extends AnyTestLayer, Harness>
+	extends MakeTrpcItOptions<CreateCaller, TestLayer> {
 	readonly makeHarness: (
-		trpc: EffectCallerFactory<
-			CallerOptions<CreateCaller>,
-			CallerResult<CreateCaller>
-		>,
+		trpc: EffectCallerFactory<CallerOptions<CreateCaller>, CallerResult<CreateCaller>>,
 		context: TestContext,
 	) => Effect.Effect<Harness, unknown, Layer.Success<TestLayer>>;
 }
 
-export type CallerOptions<CreateCaller> = CreateCaller extends (
-	...arguments_: infer Arguments
-) => object
-	? Arguments[0]
-	: never;
+export type CallerOptions<CreateCaller> = CreateCaller extends (...arguments_: infer Arguments) => object ? Arguments[0] : never;
 
-export type CallerResult<CreateCaller> = CreateCaller extends (
-	...arguments_: infer _Arguments
-) => infer Caller
+export type CallerResult<CreateCaller> = CreateCaller extends (...arguments_: infer _Arguments) => infer Caller
 	? Caller extends object
 		? Caller
 		: never

package/src/testing/vitest.ts

@@ -1,79 +1,47 @@
 import { it as effectIt, type Vitest } from "@effect/vitest";
 import { makeEffectIt } from "@shivaedev/effect-test";
 import { Effect, type Layer } from "effect";
-import { makeEffectCallerFactory } from "./caller.js";
-import type {
-	CallerOptions,
-	CallerResult,
-	MakeTrpcHarnessItOptions,
-	MakeTrpcItOptions,
-	TrpcHarnessIt,
-	TrpcIt,
-} from "./types.js";
+import type { AnyTestLayer } from "./any-test-layer.ts";
+import { makeEffectCallerFactory } from "./caller.ts";
+import type { CallerOptions, CallerResult, MakeTrpcHarnessItOptions, MakeTrpcItOptions, TrpcHarnessIt, TrpcIt } from "./types.ts";
 
-const withEffectTRPC = <Tester>(
-	tester: Tester,
-): Vitest.Methods & {
-	readonly effectTRPC: Tester;
-} =>
-	new Proxy(effectIt, {
+function withEffectTRPC<Tester>(tester: Tester): Vitest.Methods & { readonly effectTRPC: Tester };
+function withEffectTRPC(tester: unknown): unknown {
+	return new Proxy(effectIt, {
 		get(target, property, receiver) {
 			if (property === "effectTRPC") {
 				return tester;
 			}
 			return Reflect.get(target, property, receiver);
 		},
-	}) as Vitest.Methods & { readonly effectTRPC: Tester };
+	});
+}
 
-export const makeTrpcHarnessIt = <
-	CreateCaller extends (...arguments_: never[]) => object,
-	// biome-ignore lint/suspicious/noExplicitAny: Layer output and error are recovered with Layer utility types
-	TestLayer extends Layer.Layer<any, any, never>,
-	Harness,
->(
+export function makeTrpcHarnessIt<CreateCaller extends (...arguments_: never[]) => object, TestLayer extends AnyTestLayer, Harness>(
 	options: MakeTrpcHarnessItOptions<CreateCaller, TestLayer, Harness>,
-): TrpcHarnessIt<Harness, Layer.Success<TestLayer>> => {
-	type Options = CallerOptions<CreateCaller>;
-	type Caller = CallerResult<CreateCaller>;
-	type Provided = Layer.Success<TestLayer>;
-
+): TrpcHarnessIt<Harness, Layer.Success<TestLayer>>;
+export function makeTrpcHarnessIt<TestLayer extends AnyTestLayer, Harness>(
+	options: MakeTrpcHarnessItOptions<(options?: unknown) => object, TestLayer, Harness>,
+): unknown {
 	const { effectApp } = makeEffectIt({
 		around: options.around,
 		clock: options.clock,
 		layer: options.layer,
 		makeHarness: (context) =>
 			Effect.gen(function* () {
-				const services = yield* Effect.context<Provided>();
-				const trpc = makeEffectCallerFactory(
-					options.adapter,
-					// CreateCaller is a rest-never function type. The option and
-					// result aliases are the factory TypeScript cannot recover here.
-					options.createCaller as unknown as (options?: Options) => Caller,
-					services,
-				);
+				const services = yield* Effect.context<Layer.Success<TestLayer>>();
+				const trpc = makeEffectCallerFactory(options.adapter, options.createCaller, services);
 				return yield* options.makeHarness(trpc, context);
 			}),
 	});
 
 	return withEffectTRPC(effectApp);
-};
+}
 
-export const makeTrpcIt = <
-	CreateCaller extends (...arguments_: never[]) => object,
-	// biome-ignore lint/suspicious/noExplicitAny: Layer output and error are recovered with Layer utility types
-	TestLayer extends Layer.Layer<any, any, never>,
->(
+export const makeTrpcIt = <CreateCaller extends (...arguments_: never[]) => object, TestLayer extends AnyTestLayer>(
 	options: MakeTrpcItOptions<CreateCaller, TestLayer>,
-): TrpcIt<
-	CallerOptions<CreateCaller>,
-	CallerResult<CreateCaller>,
-	Layer.Success<TestLayer>
-> =>
+): TrpcIt<CallerOptions<CreateCaller>, CallerResult<CreateCaller>, Layer.Success<TestLayer>> =>
 	makeTrpcHarnessIt({
 		...options,
 		makeHarness: (trpc) => Effect.succeed(trpc),
-	}) as TrpcIt<
-		CallerOptions<CreateCaller>,
-		CallerResult<CreateCaller>,
-		Layer.Success<TestLayer>
-	>;
+	});