@shivaedev/effect-trpc 0.6.0 → 0.7.0

package/src/{internal/subscription-handler.ts → server/internal/makeSubscriptionHandler.ts}

@@ -3,27 +3,26 @@ import type { EffectProcedureRequestServices } from "#request-services.ts";
 import { RequestSignal } from "#request-signal.ts";
 import type { ProcedureInfo } from "#types.ts";
 import { acceptParsedInput } from "./loose.ts";
-import type { EffectSubscriptionResolver, ProcedureInvocation } from "./procedure-types.ts";
+import type { EffectSubscriptionResolver, ProcedureInvocation } from "./procedureTypes.ts";
 import type { RuntimeBridge } from "./runtime.ts";
-
-export const makeSubscriptionHandler = <RuntimeRequirements, Context, ProvidedServices, LayerError>(
-	runtime: RuntimeBridge<RuntimeRequirements>,
-	resolver: EffectSubscriptionResolver<never, ProvidedServices | NoInfer<RuntimeRequirements>, unknown>,
-	requestServices: EffectProcedureRequestServices<Context, ProvidedServices, LayerError>,
+export function makeSubscriptionHandler<TRuntimeRequirements, TContext, TProvidedServices, TLayerError>(
+	runtime: RuntimeBridge<TRuntimeRequirements>,
+	resolver: EffectSubscriptionResolver<never, TProvidedServices | NoInfer<TRuntimeRequirements>, unknown>,
+	requestServices: EffectProcedureRequestServices<TContext, TProvidedServices, TLayerError>,
 	procedure: Omit<ProcedureInfo, "path">,
 	outputSchema?: Schema.ConstraintDecoder<unknown>,
-) => {
+) {
 	const tracedResolver = Effect.fnUntraced(acceptParsedInput(resolver));
-
-	return async (invocation: ProcedureInvocation<Context>) => {
+	return async (invocation: ProcedureInvocation<TContext>) => {
 		const info = { ...procedure, path: invocation.path };
-		const requestLayer = Layer.merge(requestServices.layer(invocation.ctx), Layer.succeed(RequestSignal, invocation.signal));
-		const stream = Stream.unwrap(Effect.suspend(() => runtime.instrument(tracedResolver(invocation.input), info))).pipe(Stream.provide(requestLayer));
+		const stream = Stream.suspend(() => {
+			const requestLayer = Layer.merge(requestServices.layer(invocation.ctx), Layer.succeed(RequestSignal, invocation.signal));
+			return Stream.unwrap(Effect.suspend(() => runtime.instrument(tracedResolver(invocation.input), info))).pipe(Stream.provide(requestLayer));
+		});
 		const decoded = outputSchema === undefined ? stream : Stream.mapEffect(stream, (value) => Schema.decodeUnknownEffect(outputSchema)(value));
-
 		return await runtime.runStream(decoded, {
 			procedure: info,
 			...(invocation.signal === undefined ? {} : { signal: invocation.signal }),
 		});
 	};
-};
+}

package/src/server/internal/procedureTypes.ts

@@ -0,0 +1,35 @@
+import type { inferProcedureBuilderResolverOptions, TRPCProcedureBuilder, TRPCUnsetMarker } from "@trpc/server";
+import type { Effect, StandardSchema, Stream } from "effect";
+export type ProcedureBuilderOf<TContext, TMeta, TContextOverrides, TInputIn, TInputOut, TOutputIn, TOutputOut> = TRPCProcedureBuilder<
+	TContext,
+	TMeta,
+	TContextOverrides,
+	TInputIn,
+	TInputOut,
+	TOutputIn,
+	TOutputOut,
+	false
+>;
+export type DefaultValue<TValue, TFallback> = TValue extends TRPCUnsetMarker ? TFallback : TValue;
+export type IntersectIfDefined<TValue, TWith> = TValue extends TRPCUnsetMarker ? TWith : TWith extends TRPCUnsetMarker ? TValue : TValue & TWith;
+export type ResolverContext<TContext, TMeta, TContextOverrides> = inferProcedureBuilderResolverOptions<
+	ProcedureBuilderOf<TContext, TMeta, TContextOverrides, TRPCUnsetMarker, TRPCUnsetMarker, TRPCUnsetMarker, TRPCUnsetMarker>
+>["ctx"];
+export type ProcedureEffect<TRequirements> = Effect.Effect<unknown, unknown, TRequirements>;
+export type EffectProcedureResolver<TInput, TRequirements, TOutput> = (input: TInput) => Generator<ProcedureEffect<TRequirements>, TOutput, never>;
+export type EffectSubscriptionResolver<TInput, TRequirements, TOutput> = (
+	input: TInput,
+) => Generator<ProcedureEffect<TRequirements>, Stream.Stream<TOutput, unknown, TRequirements>, never>;
+export interface ProcedureInvocation<TContext> {
+	readonly ctx: TContext;
+	readonly input: unknown;
+	readonly path: string;
+	readonly signal: AbortSignal | undefined;
+}
+export interface ProcedureBuilderSurface<TContext> {
+	input: (schema: StandardSchema.StandardSchemaV1) => ProcedureBuilderSurface<TContext>;
+	mutation: (resolver: (invocation: ProcedureInvocation<TContext>) => Promise<unknown>) => unknown;
+	output: (schema: StandardSchema.StandardSchemaV1) => ProcedureBuilderSurface<TContext>;
+	query: (resolver: (invocation: ProcedureInvocation<TContext>) => Promise<unknown>) => unknown;
+	subscription: (resolver: (invocation: ProcedureInvocation<TContext>) => Promise<AsyncIterable<unknown, void, unknown>>) => unknown;
+}

package/src/server/internal/runtime.ts

@@ -0,0 +1,131 @@
+import { TRPCError } from "@trpc/server";
+import { Cause, Context, Effect, Exit, Option, Result, Stream } from "effect";
+import type { EffectTRPCRuntime } from "#adapter.ts";
+import type { EffectTRPCErrorMapper, EffectTRPCInstrument, ProcedureInfo } from "#types.ts";
+import type { ContextBridge } from "./contextBridge.ts";
+
+interface RunEffectOptions {
+	readonly procedure: ProcedureInfo;
+	readonly signal?: AbortSignal;
+}
+export interface RuntimeBridge<TRequirements> {
+	readonly instrument: EffectTRPCInstrument;
+	readonly runEffect: <TValue>(effect: Effect.Effect<TValue, unknown, TRequirements>, options: RunEffectOptions) => Promise<TValue>;
+	readonly runStream: <TValue>(stream: Stream.Stream<TValue, unknown, TRequirements>, options: RunEffectOptions) => Promise<AsyncIterable<TValue>>;
+}
+function internalError(cause?: unknown): TRPCError {
+	return new TRPCError({
+		cause,
+		code: "INTERNAL_SERVER_ERROR",
+		message: "Internal server error",
+	});
+}
+function mapError(
+	error: unknown,
+	origin: "defect" | "failure",
+	procedure: ProcedureInfo,
+	consumerMapper: EffectTRPCErrorMapper | undefined,
+): TRPCError {
+	if (error instanceof TRPCError) {
+		return error;
+	}
+	try {
+		return consumerMapper?.(error, { ...procedure, origin }) ?? internalError(error);
+	} catch (mapperDefect) {
+		return internalError(mapperDefect);
+	}
+}
+function mapCause(cause: Cause.Cause<unknown>, procedure: ProcedureInfo, consumerMapper: EffectTRPCErrorMapper | undefined): TRPCError {
+	if (Cause.hasInterruptsOnly(cause)) {
+		return new TRPCError({
+			code: "CLIENT_CLOSED_REQUEST",
+			message: "Request cancelled",
+		});
+	}
+	const failure = Cause.findErrorOption(cause);
+	if (Option.isSome(failure)) {
+		return mapError(failure.value, "failure", procedure, consumerMapper);
+	}
+	const defect = Cause.findDefect(cause);
+	if (Result.isSuccess(defect)) {
+		return mapError(defect.success, "defect", procedure, consumerMapper);
+	}
+	return internalError();
+}
+function interruptOn(signal: AbortSignal | undefined): Effect.Effect<void> {
+	if (signal === undefined) {
+		return Effect.never;
+	}
+	return Effect.callback<void>((resume) => {
+		if (signal.aborted) {
+			resume(Effect.void);
+			return;
+		}
+		function abort() {
+			return resume(Effect.void);
+		}
+		signal.addEventListener("abort", abort, { once: true });
+		return Effect.sync(() => signal.removeEventListener("abort", abort));
+	});
+}
+export function makeRuntimeBridge<TRequirements, TRuntimeError>(
+	runtime: EffectTRPCRuntime<TRequirements, TRuntimeError>,
+	contextBridge: ContextBridge,
+	options: {
+		readonly instrument?: EffectTRPCInstrument;
+		readonly instrumentStream?: import("#types.ts").EffectTRPCStreamInstrument;
+		readonly mapError?: EffectTRPCErrorMapper;
+	},
+): RuntimeBridge<TRequirements> {
+	return {
+		instrument: (effect, procedure) => Effect.suspend(() => (options.instrument === undefined ? effect : options.instrument(effect, procedure))),
+		runEffect: async (effect, runOptions) => {
+			const traced = effect.pipe(
+				Effect.withSpan(
+					runOptions.procedure.path,
+					{
+						attributes: {
+							"rpc.method": runOptions.procedure.path,
+							"rpc.system": "trpc",
+							"trpc.type": runOptions.procedure.type,
+						},
+					},
+					{
+						captureStackTrace: runOptions.procedure.captureStackTrace,
+					},
+				),
+			);
+			const ambient = contextBridge.current();
+			const runnable =
+				ambient === undefined ? traced : Effect.flatMap(runtime.contextEffect, (base) => Effect.provideContext(traced, Context.merge(base, ambient)));
+			const exit = await runtime.runPromiseExit(runnable, runOptions.signal === undefined ? undefined : { signal: runOptions.signal });
+			if (Exit.isSuccess(exit)) {
+				return exit.value;
+			}
+			throw mapCause(exit.cause, runOptions.procedure, options.mapError);
+		},
+		runStream: async (stream, runOptions) => {
+			const instrumented = Stream.suspend(() =>
+				options.instrumentStream === undefined ? stream : options.instrumentStream(stream, runOptions.procedure),
+			).pipe(
+				Stream.withSpan(runOptions.procedure.path, {
+					attributes: {
+						"rpc.method": runOptions.procedure.path,
+						"rpc.system": "trpc",
+						"trpc.type": runOptions.procedure.type,
+					},
+					captureStackTrace: runOptions.procedure.captureStackTrace,
+				}),
+				Stream.interruptWhen(interruptOn(runOptions.signal)),
+				Stream.catchCause((cause) => Stream.fail(mapCause(cause, runOptions.procedure, options.mapError))),
+			);
+			const exit = await runtime.runPromiseExit(Effect.context<TRequirements>());
+			if (Exit.isFailure(exit)) {
+				throw mapCause(exit.cause, runOptions.procedure, options.mapError);
+			}
+			const ambient = contextBridge.current();
+			const provided = ambient === undefined ? exit.value : Context.merge(exit.value, ambient);
+			return Stream.toAsyncIterableWith(instrumented, provided);
+		},
+	};
+}

package/src/{rejection.ts → server/rejection.ts}

@@ -9,46 +9,49 @@ const TAXONOMY_CODES = new Map<string, TRPC_ERROR_CODE_KEY>([
 	["PreconditionFailed", "PRECONDITION_FAILED"],
 	["TooManyRequests", "TOO_MANY_REQUESTS"],
 	["AuthUnavailable", "SERVICE_UNAVAILABLE"],
+	["ServiceUnavailable", "SERVICE_UNAVAILABLE"],
+	["InternalServerError", "INTERNAL_SERVER_ERROR"],
 ]);
-
-export const rejectionCode = (tag: string): TRPC_ERROR_CODE_KEY => TAXONOMY_CODES.get(tag) ?? "BAD_REQUEST";
-
+export function rejectionCode(tag: string): TRPC_ERROR_CODE_KEY {
+	return TAXONOMY_CODES.get(tag) ?? "BAD_REQUEST";
+}
 const DeclaredRejection = Schema.StructWithRest(Schema.Struct({ _tag: Schema.String }), [Schema.Record(Schema.String, Schema.Unknown)]);
-
 export type DeclaredRejection = typeof DeclaredRejection.Type;
-
 interface InvalidInputIsReserved {
 	readonly "invalidInput is reserved for the mark on input that did not parse": never;
 }
-
 interface DeclaredEncoding {
 	readonly _tag: string;
 	readonly invalidInput?: InvalidInputIsReserved;
 }
-
 export class RejectionError extends TRPCError {
 	readonly rejection: DeclaredRejection;
-
 	constructor(rejection: DeclaredRejection, 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;
+export interface RejectWithOptions<TTag extends string> {
+	readonly code?: (tag: TTag) => TRPC_ERROR_CODE_KEY;
 }
-
-const encodeRejection = (schema: Schema.Constraint) => {
+function encodeRejection(schema: Schema.Constraint) {
 	const encode = Schema.encodeUnknownEffect(schema);
 	const tagged = Schema.decodeUnknownEffect(DeclaredRejection);
 	return (rejection: unknown) => Effect.orDie(Effect.flatMap(encode(rejection), tagged));
-};
-
-export function rejectWith<S extends Schema.ConstraintCodec<{ readonly _tag: string }, DeclaredEncoding, unknown, 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<
+	TSession extends Schema.ConstraintCodec<
+		{
+			readonly _tag: string;
+		},
+		DeclaredEncoding,
+		unknown,
+		unknown
+	>,
+>(
+	schema: TSession,
+	options?: RejectWithOptions<TSession["Type"]["_tag"]>,
+): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, Exclude<E, TSession["Type"]> | RejectionError, R | TSession["EncodingServices"]>;
 export function rejectWith(schema: Schema.Constraint, options?: RejectWithOptions<string>) {
 	const is = Schema.is(schema);
 	const encode = encodeRejection(schema);

package/src/{rejection-formatter.ts → server/rejectionFormatter.ts}

@@ -1,14 +1,13 @@
 import { StandardSchemaV1Error, type TRPCDefaultErrorShape, type TRPCError } from "@trpc/server";
-import type { EncodedRejection } from "#client/rejection.ts";
+import type { EncodedRejection } from "#rejectionDecoding.ts";
 import { type DeclaredRejection, RejectionError } from "./rejection.ts";
-
 export interface RejectionData {
 	readonly rejection?: EncodedRejection;
 }
-
-export type RejectionErrorShape = TRPCDefaultErrorShape & { readonly data: RejectionData };
-
-const inputRejection = ({ issues: [issue] }: StandardSchemaV1Error): EncodedRejection | undefined => {
+export type RejectionErrorShape = TRPCDefaultErrorShape & {
+	readonly data: RejectionData;
+};
+function inputRejection({ issues: [issue] }: StandardSchemaV1Error): EncodedRejection | undefined {
 	if (issue === undefined) {
 		return undefined;
 	}
@@ -16,11 +15,11 @@ const inputRejection = ({ issues: [issue] }: StandardSchemaV1Error): EncodedReje
 	return field === ""
 		? { _tag: "BadRequest", invalidInput: true, message: issue.message }
 		: { _tag: "BadRequest", field, invalidInput: true, message: issue.message };
-};
-
-const declared = ({ invalidInput: _reserved, ...rejection }: DeclaredRejection): EncodedRejection => rejection;
-
-const rejectionFrom = (error: TRPCError): EncodedRejection | undefined => {
+}
+function declared({ invalidInput: _reserved, ...rejection }: DeclaredRejection): EncodedRejection {
+	return rejection;
+}
+function rejectionFrom(error: TRPCError): EncodedRejection | undefined {
 	if (error instanceof RejectionError) {
 		return declared(error.rejection);
 	}
@@ -28,12 +27,20 @@ const rejectionFrom = (error: TRPCError): EncodedRejection | undefined => {
 		return inputRejection(error.cause);
 	}
 	return undefined;
-};
-
-export const withRejection = <Shape extends { readonly data: object }>(shape: Shape, error: TRPCError): Shape & { readonly data: RejectionData } => {
+}
+export function withRejection<
+	TShape extends {
+		readonly data: object;
+	},
+>(
+	shape: TShape,
+	error: TRPCError,
+): TShape & {
+	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);
+}
+export function rejectionFormatter({ shape, error }: { readonly shape: TRPCDefaultErrorShape; readonly error: TRPCError }): RejectionErrorShape {
+	return withRejection(shape, error);
+}

package/src/server/requestServices.ts

@@ -0,0 +1,23 @@
+import { type Layer as EffectLayer, Layer } from "effect";
+export interface EffectProcedureRequestServices<TContext, TRequirements, TError = never> {
+	readonly layer: (context: TContext) => EffectLayer.Layer<TRequirements, TError>;
+}
+export function makeRequestServices<TContext, TRequirements, TError = never>(
+	layer: (context: TContext) => EffectLayer.Layer<TRequirements, TError>,
+): EffectProcedureRequestServices<TContext, TRequirements, TError> {
+	return { layer };
+}
+export function extendRequestServices<
+	TBaseContext,
+	TContext extends TBaseContext,
+	TBaseRequirements,
+	TBaseError,
+	TAdditionalRequirements,
+	TAdditionalError,
+	TAdditionalDependencies extends TBaseRequirements = TBaseRequirements,
+>(
+	base: EffectProcedureRequestServices<TBaseContext, TBaseRequirements, TBaseError>,
+	additional: (context: TContext) => EffectLayer.Layer<TAdditionalRequirements, TAdditionalError, TAdditionalDependencies>,
+): EffectProcedureRequestServices<TContext, TBaseRequirements | TAdditionalRequirements, TBaseError | TAdditionalError> {
+	return makeRequestServices((context: TContext) => Layer.provideMerge(additional(context), base.layer(context)));
+}

package/src/{testing/any-test-layer.ts → server/testing/AnyTestLayer.ts}

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

package/src/{testing → server/testing}/caller.ts

@@ -1,39 +1,34 @@
 import { getTRPCErrorFromUnknown, type TRPCError } from "@trpc/server";
 import { type Context, Effect } from "effect";
 import type { EffectTRPCAdapter } from "#adapter.ts";
-
-export type EffectCaller<Caller> = {
-	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
-			: Caller[Key] extends Record<string, unknown>
-				? EffectCaller<Caller[Key]>
-				: Caller[Key];
+export type EffectCaller<TCaller> = {
+	readonly [TKey in keyof TCaller]: TCaller[TKey] extends (...arguments_: infer TArguments) => Promise<infer TResult>
+		? (...arguments_: TArguments) => Effect.Effect<TResult, TRPCError>
+		: TCaller[TKey] extends (...arguments_: infer TArguments) => infer TResult
+			? (...arguments_: TArguments) => TResult
+			: TCaller[TKey] extends Record<string, unknown>
+				? EffectCaller<TCaller[TKey]>
+				: TCaller[TKey];
 };
-
-export type EffectCallerFactory<Options, Caller> = EffectCaller<Caller> & ((options?: Options) => EffectCaller<Caller>);
-
+export type EffectCallerFactory<TOptions, TCaller> = EffectCaller<TCaller> & ((options?: TOptions) => EffectCaller<TCaller>);
 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: readonly string[], argumentsList: readonly unknown[]): Promise<unknown> => {
+function member(node: unknown, segment: string): unknown {
+	return (typeof node === "object" && node !== null) || typeof node === "function" ? Reflect.get(node, segment) : undefined;
+}
+function invoke(promiseCaller: object, path: readonly string[], argumentsList: readonly 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>(
+}
+export function makeEffectCaller<TCaller extends object, TServices>(
 	adapter: Adapter,
-	promiseCaller: Caller,
-	services: Context.Context<Services>,
-): EffectCaller<Caller>;
+	promiseCaller: TCaller,
+	services: Context.Context<TServices>,
+): EffectCaller<TCaller>;
 export function makeEffectCaller(adapter: Adapter, promiseCaller: object, services: Context.Context<never>): unknown {
-	const build = (path: readonly string[]): unknown =>
-		new Proxy(
+	function build(path: readonly string[]): unknown {
+		return new Proxy(
 			Object.assign(() => undefined, { path }),
 			{
 				apply(_target, _this, argumentsList) {
@@ -50,19 +45,19 @@ export function makeEffectCaller(adapter: Adapter, promiseCaller: object, servic
 				},
 			},
 		);
-
+	}
 	return build([]);
 }
-
-export function makeEffectCallerFactory<Options, Caller extends object, Services>(
+export function makeEffectCallerFactory<TOptions, TCaller extends object, TServices>(
 	adapter: Adapter,
-	createCaller: (options?: Options) => Caller,
-	services: Context.Context<Services>,
-): EffectCallerFactory<Options, Caller>;
+	createCaller: (options?: TOptions) => TCaller,
+	services: Context.Context<TServices>,
+): EffectCallerFactory<TOptions, TCaller>;
 export function makeEffectCallerFactory(adapter: Adapter, createCaller: (options?: unknown) => object, services: Context.Context<never>): unknown {
 	const defaultCaller = makeEffectCaller(adapter, createCaller(), services);
-	const target = (options?: unknown) => makeEffectCaller(adapter, createCaller(options), services);
-
+	function target(options?: unknown) {
+		return makeEffectCaller(adapter, createCaller(options), services);
+	}
 	return new Proxy(target, {
 		get(_target, property, receiver) {
 			if (property === "then") {

package/src/server/testing/types.ts

@@ -0,0 +1,55 @@
+import type { TestContext, Vitest } from "@effect/vitest";
+import type { Effect, Layer, Scope } from "effect";
+import type { EffectClock, EffectTestOptions } from "@shivaedev/effect-test/types.ts";
+import type { EffectTRPCAdapter } from "#adapter.ts";
+import type { AnyTestLayer } from "./AnyTestLayer.ts";
+import type { EffectCallerFactory } from "./caller.ts";
+export type TrpcHarnessTest<THarness, TProvided> = <A, TEff extends Effect.Effect<unknown, unknown, TProvided>>(
+	name: string,
+	body: (harness: THarness, context: TestContext) => Generator<TEff, A, never>,
+	options?: number | EffectTestOptions,
+) => void;
+export interface TrpcHarnessTester<THarness, TProvided> extends TrpcHarnessTest<THarness, TProvided> {
+	readonly each: <TItem>(
+		cases: readonly TItem[],
+	) => <A, TEff extends Effect.Effect<unknown, unknown, TProvided>>(
+		name: string,
+		body: (item: TItem, harness: THarness, context: TestContext) => Generator<TEff, A, never>,
+		options?: number | EffectTestOptions,
+	) => void;
+	readonly fails: TrpcHarnessTest<THarness, TProvided>;
+	readonly only: TrpcHarnessTest<THarness, TProvided>;
+	readonly runIf: (condition: unknown) => TrpcHarnessTest<THarness, TProvided>;
+	readonly skip: TrpcHarnessTest<THarness, TProvided>;
+	readonly skipIf: (condition: unknown) => TrpcHarnessTest<THarness, TProvided>;
+}
+export type TrpcTest<TOptions, TCaller, TProvided> = TrpcHarnessTest<EffectCallerFactory<TOptions, TCaller>, TProvided>;
+export type TrpcTester<TOptions, TCaller, TProvided> = TrpcHarnessTester<EffectCallerFactory<TOptions, TCaller>, TProvided>;
+export type TrpcIt<TOptions, TCaller, TProvided> = Vitest.Methods & {
+	readonly "effectTRPC": TrpcTester<TOptions, TCaller, TProvided>;
+};
+export type TrpcHarnessIt<THarness, TProvided> = Vitest.Methods & {
+	readonly "effectTRPC": TrpcHarnessTester<THarness, TProvided>;
+};
+export interface MakeTrpcItOptions<TCreateCaller extends (...arguments_: never[]) => object, TTestLayer extends AnyTestLayer> {
+	readonly adapter: Pick<EffectTRPCAdapter<never>, "runWithServices">;
+	readonly around?: <A, E>(
+		effect: Effect.Effect<A, E, Layer.Success<TTestLayer> | Scope.Scope>,
+	) => Effect.Effect<A, unknown, Layer.Success<TTestLayer> | Scope.Scope>;
+	readonly clock?: EffectClock;
+	readonly createCaller: TCreateCaller;
+	readonly layer: TTestLayer;
+}
+export interface MakeTrpcHarnessItOptions<TCreateCaller extends (...arguments_: never[]) => object, TTestLayer extends AnyTestLayer, THarness>
+	extends MakeTrpcItOptions<TCreateCaller, TTestLayer> {
+	readonly makeHarness: (
+		trpc: EffectCallerFactory<CallerOptions<TCreateCaller>, CallerResult<TCreateCaller>>,
+		context: TestContext,
+	) => Effect.Effect<THarness, unknown, Layer.Success<TTestLayer>>;
+}
+export type CallerOptions<TCreateCaller> = TCreateCaller extends (...arguments_: infer TArguments) => object ? TArguments[0] : never;
+export type CallerResult<TCreateCaller> = TCreateCaller extends (...arguments_: infer _TArguments) => infer TCaller
+	? TCaller extends object
+		? TCaller
+		: never
+	: never;

package/src/{testing → server/testing}/vitest.ts

@@ -1,12 +1,14 @@
 import { it as effectIt, type Vitest } from "@effect/vitest";
 import { Effect, type Layer } from "effect";
 import { makeEffectIt } from "@shivaedev/effect-test/vitest.ts";
-import type { AnyTestLayer } from "./any-test-layer.ts";
+import type { AnyTestLayer } from "./AnyTestLayer.ts";
 import { makeEffectCallerFactory } from "./caller.ts";
 import type { CallerOptions, CallerResult, MakeTrpcHarnessItOptions, MakeTrpcItOptions, TrpcHarnessIt, TrpcIt } from "./types.ts";
 
-function withEffectTRPC<Tester>(tester: Tester): Vitest.Methods & { readonly effectTRPC: Tester };
-function withEffectTRPC(tester: unknown): unknown {
+function withEffectTrpc<TTester>(tester: TTester): Vitest.Methods & {
+	readonly "effectTRPC": TTester;
+};
+function withEffectTrpc(tester: unknown): unknown {
 	return new Proxy(effectIt, {
 		get(target, property, receiver) {
 			if (property === "effectTRPC") {
@@ -16,12 +18,11 @@ function withEffectTRPC(tester: unknown): unknown {
 		},
 	});
 }
-
-export function makeTrpcHarnessIt<CreateCaller extends (...arguments_: never[]) => object, TestLayer extends AnyTestLayer, Harness>(
-	options: MakeTrpcHarnessItOptions<CreateCaller, TestLayer, Harness>,
-): TrpcHarnessIt<Harness, Layer.Success<TestLayer>>;
-export function makeTrpcHarnessIt<TestLayer extends AnyTestLayer, Harness>(
-	options: MakeTrpcHarnessItOptions<(options?: unknown) => object, TestLayer, Harness>,
+export function makeTrpcHarnessIt<TCreateCaller extends (...arguments_: never[]) => object, TTestLayer extends AnyTestLayer, THarness>(
+	options: MakeTrpcHarnessItOptions<TCreateCaller, TTestLayer, THarness>,
+): TrpcHarnessIt<THarness, Layer.Success<TTestLayer>>;
+export function makeTrpcHarnessIt<TTestLayer extends AnyTestLayer, THarness>(
+	options: MakeTrpcHarnessItOptions<(options?: unknown) => object, TTestLayer, THarness>,
 ): unknown {
 	const { effectApp } = makeEffectIt({
 		around: options.around,
@@ -29,19 +30,18 @@ export function makeTrpcHarnessIt<TestLayer extends AnyTestLayer, Harness>(
 		layer: options.layer,
 		makeHarness: (context) =>
 			Effect.gen(function* () {
-				const services = yield* Effect.context<Layer.Success<TestLayer>>();
+				const services = yield* Effect.context<Layer.Success<TTestLayer>>();
 				const trpc = makeEffectCallerFactory(options.adapter, options.createCaller, services);
 				return yield* options.makeHarness(trpc, context);
 			}),
 	});
-
-	return withEffectTRPC(effectApp);
+	return withEffectTrpc(effectApp);
 }
-
-export const makeTrpcIt = <CreateCaller extends (...arguments_: never[]) => object, TestLayer extends AnyTestLayer>(
-	options: MakeTrpcItOptions<CreateCaller, TestLayer>,
-): TrpcIt<CallerOptions<CreateCaller>, CallerResult<CreateCaller>, Layer.Success<TestLayer>> =>
-	makeTrpcHarnessIt({
+export function makeTrpcIt<TCreateCaller extends (...arguments_: never[]) => object, TTestLayer extends AnyTestLayer>(
+	options: MakeTrpcItOptions<TCreateCaller, TTestLayer>,
+): TrpcIt<CallerOptions<TCreateCaller>, CallerResult<TCreateCaller>, Layer.Success<TTestLayer>> {
+	return makeTrpcHarnessIt({
 		...options,
 		makeHarness: (trpc) => Effect.succeed(trpc),
 	});
+}

package/src/{types.ts → server/types.ts}

@@ -1,20 +1,14 @@
 import type { TRPCError } from "@trpc/server";
 import type { Effect, Stream } from "effect";
-
 export type ProcedureKind = "mutation" | "query" | "subscription";
-
 export interface ProcedureInfo {
 	readonly captureStackTrace: () => string | undefined;
 	readonly path: string;
 	readonly type: ProcedureKind;
 }
-
 export interface EffectTRPCErrorContext extends ProcedureInfo {
 	readonly origin: "defect" | "failure";
 }
-
 export type EffectTRPCErrorMapper = (error: unknown, context: EffectTRPCErrorContext) => TRPCError | undefined;
-
 export type EffectTRPCInstrument = <A, E, R>(effect: Effect.Effect<A, E, R>, procedure: ProcedureInfo) => Effect.Effect<A, E, R>;
-
 export type EffectTRPCStreamInstrument = <A, E, R>(stream: Stream.Stream<A, E, R>, procedure: ProcedureInfo) => Stream.Stream<A, E, R>;

package/dist/adapter.d.ts

@@ -1,29 +0,0 @@
-import type { TRPCProcedureBuilder } from "@trpc/server";
-import type { Context, Effect, Exit } from "effect";
-import type { ResolverContext } from "#internal/procedure-types.ts";
-import { EffectProcedureBuilder } from "./procedure.ts";
-import type { EffectProcedureRequestServices } from "./request-services.ts";
-import type { EffectTRPCErrorMapper, EffectTRPCInstrument, EffectTRPCStreamInstrument } from "./types.ts";
-export interface MakeEffectTRPCOptions<Requirements, RuntimeError> {
-    readonly instrument?: EffectTRPCInstrument;
-    readonly instrumentStream?: EffectTRPCStreamInstrument;
-    readonly mapError?: EffectTRPCErrorMapper;
-    readonly runtime: EffectTRPCRuntime<Requirements, RuntimeError>;
-}
-export interface EffectTRPCRuntime<Requirements, RuntimeError> {
-    readonly contextEffect: Effect.Effect<Context.Context<Requirements>, RuntimeError>;
-    readonly currentServices?: () => Context.Context<never> | undefined;
-    readonly runPromise: <Value, Error>(effect: Effect.Effect<Value, Error, Requirements>, options?: {
-        readonly signal?: AbortSignal;
-    }) => Promise<Value>;
-    readonly runPromiseExit: <Value, Error>(effect: Effect.Effect<Value, Error, Requirements>, options?: {
-        readonly signal?: AbortSignal;
-    }) => Promise<Exit.Exit<Value, Error | RuntimeError>>;
-    readonly runWithServices?: <Services, Value>(services: Context.Context<Services>, evaluate: () => Value) => Value;
-}
-export interface EffectTRPCAdapter<Requirements> {
-    readonly procedure: <Context, Meta, ContextOverrides, InputIn, InputOut, OutputIn, OutputOut, ProvidedServices, LayerError>(builder: TRPCProcedureBuilder<Context, Meta, ContextOverrides, InputIn, InputOut, OutputIn, OutputOut, false>, requestServices: EffectProcedureRequestServices<ResolverContext<Context, Meta, ContextOverrides>, ProvidedServices, LayerError>) => EffectProcedureBuilder<Context, Meta, ContextOverrides, InputIn, InputOut, OutputIn, OutputOut, ProvidedServices, LayerError, Requirements>;
-    readonly runWithServices: <Services, Value>(services: Context.Context<Services>, evaluate: () => Value) => Value;
-}
-export declare const makeEffectTRPC: <Requirements, RuntimeError = never>(options: MakeEffectTRPCOptions<Requirements, RuntimeError>) => EffectTRPCAdapter<Requirements>;
-//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"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"}

package/dist/adapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAiCxD,MAAM,CAAC,MAAM,cAAc,GAAG,CAC7B,OAA0D,EACxB,EAAE;IACpC,MAAM,aAAa,GAAG,iBAAiB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACzD,MAAM,OAAO,GAAG,iBAAiB,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IAE3E,OAAO;QACN,SAAS,EAAE,CACV,OAA6G,EAC7G,eAA+H,EAC9H,EAAE;YACH,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;YACpC,OAAO,IAAI,sBAAsB,CAW/B;gBACD,OAAO,EAAE,KAAK;gBACd,eAAe;gBACf,OAAO;gBACP,mBAAmB,EAAE,KAAK;aAC1B,CAAC,CAAC;QACJ,CAAC;QACD,eAAe,EAAE,aAAa,CAAC,GAAG;KAClC,CAAC;AACH,CAAC,CAAC"}