@shivaedev/effect-trpc 0.0.0

package/src/testing/types.ts

@@ -0,0 +1,81 @@
+import type { TestContext, TestOptions, Vitest } from "@effect/vitest";
+import type { Effect, Layer } from "effect";
+import type { EffectTRPCAdapter } from "../adapter.js";
+import type { EffectCallerFactory } from "./caller.js";
+
+export type TrpcTest<Options, Caller, Provided> = <
+	A,
+	Eff extends Effect.Effect<unknown, unknown, Provided>,
+>(
+	name: string,
+	body: (
+		trpc: EffectCallerFactory<Options, Caller>,
+		context: TestContext,
+	) => Generator<Eff, A, never>,
+	options?: number | TestOptions,
+) => void;
+
+export interface TrpcTester<Options, Caller, Provided>
+	extends TrpcTest<Options, Caller, Provided> {
+	readonly skip: TrpcTest<Options, Caller, Provided>;
+	readonly skipIf: (condition: unknown) => TrpcTest<Options, Caller, Provided>;
+	readonly runIf: (condition: unknown) => TrpcTest<Options, Caller, Provided>;
+	readonly only: TrpcTest<Options, Caller, Provided>;
+	readonly each: <Item>(
+		cases: ReadonlyArray<Item>,
+	) => <A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
+		name: string,
+		body: (
+			item: Item,
+			trpc: EffectCallerFactory<Options, Caller>,
+			context: TestContext,
+		) => Generator<Eff, A, never>,
+		options?: number | TestOptions,
+	) => void;
+	readonly fails: TrpcTest<Options, Caller, Provided>;
+}
+
+export type TrpcIt<Options, Caller, Provided> = Vitest.Methods & {
+	readonly effectTRPC: TrpcTester<Options, Caller, Provided>;
+};
+
+export interface TrpcTestRuntimeOptions<
+	Options,
+	Caller extends object,
+	Provided,
+	LayerError,
+> {
+	readonly adapter: Pick<EffectTRPCAdapter<never>, "runWithServices">;
+	readonly around?: <A, E>(
+		effect: Effect.Effect<A, E, Provided>,
+	) => Effect.Effect<A, unknown, Provided>;
+	readonly createCaller: (options?: Options) => Caller;
+	readonly layer: Layer.Layer<Provided, LayerError>;
+}
+
+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>,
+> {
+	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 createCaller: CreateCaller;
+	readonly layer: TestLayer;
+}
+
+export type CallerOptions<CreateCaller> = CreateCaller extends (
+	...arguments_: infer Arguments
+) => object
+	? Arguments[0]
+	: never;
+
+export type CallerResult<CreateCaller> = CreateCaller extends (
+	...arguments_: infer _Arguments
+) => infer Caller
+	? Caller extends object
+		? Caller
+		: never
+	: never;

package/src/testing/vitest.ts

@@ -0,0 +1,64 @@
+import { it as effectIt } from "@effect/vitest";
+import { Effect, Exit, Layer, Scope } from "effect";
+import {
+	type FixtureTestApi,
+	fixtureName,
+	makeTrpcTester,
+} from "../internal/vitest-trpc.js";
+import type {
+	CallerOptions,
+	CallerResult,
+	MakeTrpcItOptions,
+	TrpcIt,
+} from "./types.js";
+
+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>,
+>(
+	options: MakeTrpcItOptions<CreateCaller, TestLayer>,
+): TrpcIt<
+	CallerOptions<CreateCaller>,
+	CallerResult<CreateCaller>,
+	Layer.Success<TestLayer>
+> => {
+	type Options = CallerOptions<CreateCaller>;
+	type Caller = CallerResult<CreateCaller>;
+	type Provided = Layer.Success<TestLayer>;
+
+	const fixtureIt = effectIt.extend(
+		fixtureName,
+		{ scope: "worker" },
+		// biome-ignore lint/correctness/noEmptyPattern: Vitest fixtures require a destructured context parameter.
+		async ({}, { onCleanup }) => {
+			const scope = Effect.runSync(Scope.make());
+			onCleanup(() => Effect.runPromise(Scope.close(scope, Exit.void)));
+
+			try {
+				return await Effect.runPromise(
+					Layer.buildWithScope(options.layer, scope),
+				);
+			} catch (error) {
+				await Effect.runPromise(Scope.close(scope, Exit.void));
+				throw error;
+			}
+		},
+	);
+
+	const effectTRPC = makeTrpcTester(
+		fixtureIt as unknown as FixtureTestApi<Provided>,
+		options as unknown as Parameters<
+			typeof makeTrpcTester<Options, Caller, Provided, Layer.Error<TestLayer>>
+		>[1],
+	);
+
+	return new Proxy(effectIt, {
+		get(target, property, receiver) {
+			if (property === "effectTRPC") {
+				return effectTRPC;
+			}
+			return Reflect.get(target, property, receiver);
+		},
+	}) as TrpcIt<Options, Caller, Provided>;
+};

package/src/testing.ts

@@ -0,0 +1,13 @@
+export {
+	type EffectCaller,
+	type EffectCallerFactory,
+	makeEffectCaller,
+	makeEffectCallerFactory,
+} from "./testing/caller.js";
+export type {
+	MakeTrpcItOptions,
+	TrpcIt,
+	TrpcTest,
+	TrpcTester,
+} from "./testing/types.js";
+export { makeTrpcIt } from "./testing/vitest.js";

package/src/types.ts

@@ -0,0 +1,24 @@
+import type { TRPCError } from "@trpc/server";
+import type { Effect } from "effect";
+
+export type ProcedureKind = "mutation" | "query";
+
+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>;