@shivaedev/effect-trpc 0.0.0

package/src/internal/runtime.ts

@@ -0,0 +1,131 @@
+import { TRPCError } from "@trpc/server";
+import {
+	Cause,
+	Context,
+	Effect,
+	Exit,
+	type ManagedRuntime,
+	Option,
+	Result,
+} from "effect";
+import type {
+	EffectTRPCErrorMapper,
+	EffectTRPCInstrument,
+	ProcedureInfo,
+} from "../types.js";
+import type { ContextBridge } from "./context-bridge.js";
+
+interface RunEffectOptions {
+	readonly procedure: ProcedureInfo;
+	readonly signal?: AbortSignal;
+}
+
+export interface RuntimeBridge<Requirements> {
+	readonly runEffect: <Value>(
+		effect: Effect.Effect<Value, unknown, Requirements>,
+		options: RunEffectOptions,
+	) => Promise<Value>;
+}
+
+const internalError = (cause?: unknown): TRPCError =>
+	new TRPCError({
+		cause,
+		code: "INTERNAL_SERVER_ERROR",
+		message: "Internal server error",
+	});
+
+const 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);
+	}
+};
+
+export const makeRuntimeBridge = <Requirements, RuntimeError>(
+	runtime: ManagedRuntime.ManagedRuntime<Requirements, RuntimeError>,
+	contextBridge: ContextBridge,
+	options: {
+		readonly instrument?: EffectTRPCInstrument;
+		readonly mapError?: EffectTRPCErrorMapper;
+	},
+): RuntimeBridge<Requirements> => ({
+	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 instrumented = Effect.suspend(() =>
+			options.instrument === undefined
+				? traced
+				: options.instrument(traced, runOptions.procedure),
+		);
+		const ambient = contextBridge.current();
+		const runnable =
+			ambient === undefined
+				? instrumented
+				: Effect.flatMap(runtime.contextEffect, (base) =>
+						Effect.provideContext(instrumented, Context.merge(base, ambient)),
+					);
+		const exit = await runtime.runPromiseExit(
+			runnable,
+			runOptions.signal === undefined
+				? undefined
+				: { signal: runOptions.signal },
+		);
+
+		if (Exit.isSuccess(exit)) {
+			return exit.value;
+		}
+		if (Cause.hasInterruptsOnly(exit.cause)) {
+			throw new TRPCError({
+				code: "CLIENT_CLOSED_REQUEST",
+				message: "Request cancelled",
+			});
+		}
+
+		const failure = Cause.findErrorOption(exit.cause);
+		if (Option.isSome(failure)) {
+			throw mapError(
+				failure.value,
+				"failure",
+				runOptions.procedure,
+				options.mapError,
+			);
+		}
+
+		const defect = Cause.findDefect(exit.cause);
+		if (Result.isSuccess(defect)) {
+			throw mapError(
+				defect.success,
+				"defect",
+				runOptions.procedure,
+				options.mapError,
+			);
+		}
+
+		throw internalError();
+	},
+});

package/src/internal/stack-trace.ts

@@ -0,0 +1,19 @@
+export const captureStackTrace = (): (() => string | undefined) => {
+	const limit = Error.stackTraceLimit;
+	Error.stackTraceLimit = 3;
+	const traceError = new Error();
+	Error.stackTraceLimit = limit;
+
+	let cache: false | string = false;
+	return () => {
+		if (cache !== false) {
+			return cache;
+		}
+		const frame = traceError.stack?.split("\n")[3];
+		if (frame !== undefined) {
+			cache = frame.trim();
+			return cache;
+		}
+		return undefined;
+	};
+};

package/src/internal/vitest-trpc.ts

@@ -0,0 +1,202 @@
+import type { TestContext, TestOptions } from "@effect/vitest";
+import { Cause, type Context, Effect, Exit, Layer, type Scope } from "effect";
+import * as TestClock from "effect/testing/TestClock";
+import * as TestConsole from "effect/testing/TestConsole";
+import { makeEffectCallerFactory } from "../testing/caller.js";
+import type {
+	TrpcTest,
+	TrpcTester,
+	TrpcTestRuntimeOptions,
+} from "../testing/types.js";
+
+export const fixtureName = "__effectTrpcContext";
+
+export type TrpcFixture<Provided> = TestContext & {
+	readonly [fixtureName]: Context.Context<Provided>;
+};
+
+export interface FixtureTestApi<Provided> {
+	(
+		name: string,
+		options: TestOptions,
+		body: (context: TrpcFixture<Provided>) => Promise<unknown>,
+	): void;
+	readonly skip: FixtureTestApi<Provided>;
+	readonly skipIf: (condition: unknown) => FixtureTestApi<Provided>;
+	readonly runIf: (condition: unknown) => FixtureTestApi<Provided>;
+	readonly only: FixtureTestApi<Provided>;
+	readonly fails: FixtureTestApi<Provided>;
+	readonly for: <Item>(
+		cases: ReadonlyArray<Item>,
+	) => (
+		name: string,
+		options: TestOptions,
+		body: (item: Item, context: TrpcFixture<Provided>) => Promise<unknown>,
+	) => void;
+}
+
+const TestEnvironment = Layer.mergeAll(TestConsole.layer, TestClock.layer());
+
+const normalizeTestOptions = (
+	options: number | TestOptions | undefined,
+): TestOptions =>
+	typeof options === "number" ? { timeout: options } : (options ?? {});
+
+const restoreContext = <Provided>(
+	fixture: Context.Context<Provided>,
+	context: Omit<TrpcFixture<Provided>, typeof fixtureName>,
+): TrpcFixture<Provided> =>
+	({ ...context, [fixtureName]: fixture }) as TrpcFixture<Provided>;
+
+const contextFrom = <Provided>(
+	context: TestContext,
+): Context.Context<Provided> => (context as TrpcFixture<Provided>)[fixtureName];
+
+const runEffectTest = <A, E>(
+	effect: Effect.Effect<A, E, Scope.Scope>,
+	context: TestContext,
+): Promise<A> =>
+	Effect.runPromise(
+		Effect.gen(function* () {
+			const exit = yield* Effect.exit(effect);
+			if (Exit.isFailure(exit)) {
+				for (const error of Cause.prettyErrors(exit.cause)) {
+					yield* Effect.logError(error);
+				}
+			}
+			return yield* exit;
+		}).pipe(Effect.scoped, Effect.provide(TestEnvironment)),
+		{ signal: context.signal },
+	);
+
+export const makeTrpcTester = <
+	Options,
+	Caller extends object,
+	Provided,
+	LayerError,
+>(
+	fixtureIt: FixtureTestApi<Provided>,
+	options: TrpcTestRuntimeOptions<Options, Caller, Provided, LayerError>,
+): TrpcTester<Options, Caller, Provided> => {
+	const run = <A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
+		body: (
+			trpc: ReturnType<
+				typeof makeEffectCallerFactory<Options, Caller, Provided>
+			>,
+			context: TestContext,
+		) => Generator<Eff, A, never>,
+		context: TestContext,
+	): Effect.Effect<A, unknown, Scope.Scope> => {
+		const program = Effect.gen(function* () {
+			const services = yield* Effect.context<Provided>();
+			const trpc = makeEffectCallerFactory(
+				options.adapter,
+				options.createCaller,
+				services,
+			);
+			return yield* Effect.gen(() => body(trpc, context));
+		});
+		// The body constraint proves every yielded service is part of Provided.
+		// TypeScript cannot reduce that generic generator requirement here.
+		const ready = program as Effect.Effect<A, unknown, Provided>;
+		const wrapped = options.around?.(ready) ?? ready;
+		return wrapped.pipe(
+			Effect.provide(contextFrom<Provided>(context)),
+		) as Effect.Effect<A, unknown, Scope.Scope>;
+	};
+
+	const register =
+		(current: FixtureTestApi<Provided>): TrpcTest<Options, Caller, Provided> =>
+		(name, body, testOptions) =>
+			current(
+				name,
+				normalizeTestOptions(testOptions),
+				({
+					__effectTrpcContext,
+					task,
+					signal,
+					onTestFailed,
+					onTestFinished,
+					skip,
+					annotate,
+					expect,
+					_local,
+				}: TrpcFixture<Provided>) => {
+					const context = restoreContext(__effectTrpcContext, {
+						task,
+						signal,
+						onTestFailed,
+						onTestFinished,
+						skip,
+						annotate,
+						expect,
+						_local,
+					});
+					return runEffectTest(run(body, context), context);
+				},
+			);
+
+	const make = (
+		current: FixtureTestApi<Provided>,
+	): TrpcTester<Options, Caller, Provided> => {
+		const test = register(current);
+		return Object.assign(test, {
+			skip: register(current.skip),
+			skipIf: (condition: unknown) => register(current.skipIf(condition)),
+			runIf: (condition: unknown) => register(current.runIf(condition)),
+			only: register(current.only),
+			each:
+				<Item>(cases: ReadonlyArray<Item>) =>
+				<A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
+					name: string,
+					body: (
+						item: Item,
+						trpc: ReturnType<
+							typeof makeEffectCallerFactory<Options, Caller, Provided>
+						>,
+						context: TestContext,
+					) => Generator<Eff, A, never>,
+					testOptions?: number | TestOptions,
+				) =>
+					fixtureIt.for(cases)(
+						name,
+						normalizeTestOptions(testOptions),
+						(
+							item,
+							{
+								__effectTrpcContext,
+								task,
+								signal,
+								onTestFailed,
+								onTestFinished,
+								skip,
+								annotate,
+								expect,
+								_local,
+							}: TrpcFixture<Provided>,
+						) => {
+							const context = restoreContext(__effectTrpcContext, {
+								task,
+								signal,
+								onTestFailed,
+								onTestFinished,
+								skip,
+								annotate,
+								expect,
+								_local,
+							});
+							return runEffectTest(
+								run(
+									(trpc, testContext) => body(item, trpc, testContext),
+									context,
+								),
+								context,
+							);
+						},
+					),
+			fails: register(current.fails),
+		});
+	};
+
+	return make(fixtureIt);
+};

package/src/procedure.ts

@@ -0,0 +1,191 @@
+import type {
+	TRPCMutationProcedure,
+	TRPCProcedureBuilder,
+	TRPCQueryProcedure,
+} from "@trpc/server";
+import { Schema } from "effect";
+import { makeProcedureHandler } from "./internal/procedure-handler.js";
+import type {
+	DefaultValue,
+	EffectProcedureResolver,
+	IntersectIfDefined,
+	ResolverContext,
+} from "./internal/procedure-types.js";
+import type { RuntimeBridge } from "./internal/runtime.js";
+import { captureStackTrace } from "./internal/stack-trace.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
+>;
+
+export class EffectProcedureBuilder<
+	Context,
+	Meta,
+	ContextOverrides,
+	InputIn,
+	InputOut,
+	OutputIn,
+	OutputOut,
+	ProvidedServices,
+	LayerError,
+	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 runtime: RuntimeBridge<RuntimeRequirements>,
+	) {}
+
+	input<SchemaValue extends Schema.ConstraintDecoder<unknown>>(
+		schema: SchemaValue,
+	): EffectProcedureBuilder<
+		Context,
+		Meta,
+		ContextOverrides,
+		IntersectIfDefined<InputIn, SchemaValue["Encoded"]>,
+		IntersectIfDefined<InputOut, SchemaValue["Type"]>,
+		OutputIn,
+		OutputOut,
+		ProvidedServices,
+		LayerError,
+		RuntimeRequirements
+	> {
+		const next = this.builder.input(Schema.toStandardSchemaV1(schema) as never);
+		return new EffectProcedureBuilder(
+			next as unknown as Builder<
+				Context,
+				Meta,
+				ContextOverrides,
+				IntersectIfDefined<InputIn, SchemaValue["Encoded"]>,
+				IntersectIfDefined<InputOut, SchemaValue["Type"]>,
+				OutputIn,
+				OutputOut
+			>,
+			this.requestServices,
+			this.runtime,
+		);
+	}
+
+	output<SchemaValue extends Schema.ConstraintDecoder<unknown>>(
+		schema: SchemaValue,
+	): EffectProcedureBuilder<
+		Context,
+		Meta,
+		ContextOverrides,
+		InputIn,
+		InputOut,
+		IntersectIfDefined<OutputIn, SchemaValue["Encoded"]>,
+		IntersectIfDefined<OutputOut, SchemaValue["Type"]>,
+		ProvidedServices,
+		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.requestServices,
+			this.runtime,
+		);
+	}
+
+	query<Output>(
+		resolver: EffectProcedureResolver<
+			DefaultValue<InputOut, undefined>,
+			ProvidedServices | NoInfer<RuntimeRequirements>,
+			DefaultValue<OutputIn, Output>
+		>,
+	): TRPCQueryProcedure<{
+		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;
+		}>;
+	}
+
+	mutation<Output>(
+		resolver: EffectProcedureResolver<
+			DefaultValue<InputOut, undefined>,
+			ProvidedServices | NoInfer<RuntimeRequirements>,
+			DefaultValue<OutputIn, Output>
+		>,
+	): TRPCMutationProcedure<{
+		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;
+		}>;
+	}
+
+	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);
+	}
+}

package/src/request-services.ts

@@ -0,0 +1,43 @@
+import { type Layer as EffectLayer, Layer } from "effect";
+
+export interface EffectProcedureRequestServices<
+	Context,
+	Requirements,
+	Error = never,
+> {
+	readonly layer: (context: Context) => EffectLayer.Layer<Requirements, Error>;
+}
+
+export const makeRequestServices = <Context, Requirements, Error = never>(
+	layer: (context: Context) => EffectLayer.Layer<Requirements, Error>,
+): EffectProcedureRequestServices<Context, Requirements, Error> => ({ layer });
+
+export const extendRequestServices = <
+	BaseContext,
+	Context extends BaseContext,
+	BaseRequirements,
+	BaseError,
+	AdditionalRequirements,
+	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)),
+	);

package/src/testing/caller.ts

@@ -0,0 +1,80 @@
+import { getTRPCErrorFromUnknown, type TRPCError } from "@trpc/server";
+import { type Context, Effect } from "effect";
+import type { EffectTRPCAdapter } from "../adapter.js";
+
+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 EffectCallerFactory<Options, Caller> = EffectCaller<Caller> &
+	((options?: Options) => EffectCaller<Caller>);
+
+export const makeEffectCaller = <Caller extends object, Services>(
+	adapter: Pick<EffectTRPCAdapter<never>, "runWithServices">,
+	promiseCaller: Caller,
+	services: Context.Context<Services>,
+): EffectCaller<Caller> => {
+	const build = (path: ReadonlyArray<string>): unknown =>
+		new Proxy(
+			Object.assign(() => undefined, { path }),
+			{
+				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,
+								);
+							}),
+					});
+				},
+				get(_target, property) {
+					if (typeof property !== "string" || property === "then") {
+						return undefined;
+					}
+					return build([...path, property]);
+				},
+			},
+		);
+
+	return build([]) as EffectCaller<Caller>;
+};
+
+export const makeEffectCallerFactory = <
+	Options,
+	Caller extends object,
+	Services,
+>(
+	adapter: Pick<EffectTRPCAdapter<never>, "runWithServices">,
+	createCaller: (options?: Options) => Caller,
+	services: Context.Context<Services>,
+): EffectCallerFactory<Options, Caller> => {
+	const defaultCaller = makeEffectCaller(adapter, createCaller(), services);
+	const target = (options?: Options) =>
+		makeEffectCaller(adapter, createCaller(options), services);
+
+	return new Proxy(target, {
+		get(_target, property, receiver) {
+			if (property === "then") {
+				return undefined;
+			}
+			if (typeof property !== "string") {
+				return Reflect.get(_target, property, receiver);
+			}
+			return Reflect.get(defaultCaller, property);
+		},
+	}) as EffectCallerFactory<Options, Caller>;
+};