@shivaedev/effect-trpc 0.1.1 → 0.3.0

package/src/internal/vitest-trpc.ts

@@ -4,7 +4,9 @@ import * as TestClock from "effect/testing/TestClock";
 import * as TestConsole from "effect/testing/TestConsole";
 import { makeEffectCallerFactory } from "../testing/caller.js";
 import type {
-	TrpcTest,
+	TrpcHarnessTest,
+	TrpcHarnessTester,
+	TrpcHarnessTestRuntimeOptions,
 	TrpcTester,
 	TrpcTestRuntimeOptions,
 } from "../testing/types.js";
@@ -69,22 +71,24 @@ const runEffectTest = <A, E>(
 		{ signal: context.signal },
 	);
 
-export const makeTrpcTester = <
+export const makeTrpcHarnessTester = <
 	Options,
 	Caller extends object,
+	Harness,
 	Provided,
 	LayerError,
 >(
 	fixtureIt: FixtureTestApi<Provided>,
-	options: TrpcTestRuntimeOptions<Options, Caller, Provided, LayerError>,
-): TrpcTester<Options, Caller, Provided> => {
+	options: TrpcHarnessTestRuntimeOptions<
+		Options,
+		Caller,
+		Harness,
+		Provided,
+		LayerError
+	>,
+): TrpcHarnessTester<Harness, 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>,
+		body: (harness: Harness, context: TestContext) => Generator<Eff, A, never>,
 		context: TestContext,
 	): Effect.Effect<A, unknown, Scope.Scope> => {
 		const program = Effect.gen(function* () {
@@ -94,7 +98,8 @@ export const makeTrpcTester = <
 				options.createCaller,
 				services,
 			);
-			return yield* Effect.gen(() => body(trpc, context));
+			const harness = yield* options.makeHarness(trpc, context);
+			return yield* Effect.gen(() => body(harness, context));
 		});
 		// The body constraint proves every yielded service is part of Provided.
 		// TypeScript cannot reduce that generic generator requirement here.
@@ -106,7 +111,7 @@ export const makeTrpcTester = <
 	};
 
 	const register =
-		(current: FixtureTestApi<Provided>): TrpcTest<Options, Caller, Provided> =>
+		(current: FixtureTestApi<Provided>): TrpcHarnessTest<Harness, Provided> =>
 		(name, body, testOptions) =>
 			current(
 				name,
@@ -138,7 +143,7 @@ export const makeTrpcTester = <
 
 	const make = (
 		current: FixtureTestApi<Provided>,
-	): TrpcTester<Options, Caller, Provided> => {
+	): TrpcHarnessTester<Harness, Provided> => {
 		const test = register(current);
 		return Object.assign(test, {
 			skip: register(current.skip),
@@ -151,9 +156,7 @@ export const makeTrpcTester = <
 					name: string,
 					body: (
 						item: Item,
-						trpc: ReturnType<
-							typeof makeEffectCallerFactory<Options, Caller, Provided>
-						>,
+						harness: Harness,
 						context: TestContext,
 					) => Generator<Eff, A, never>,
 					testOptions?: number | TestOptions,
@@ -187,7 +190,7 @@ export const makeTrpcTester = <
 							});
 							return runEffectTest(
 								run(
-									(trpc, testContext) => body(item, trpc, testContext),
+									(harness, testContext) => body(item, harness, testContext),
 									context,
 								),
 								context,
@@ -200,3 +203,17 @@ export const makeTrpcTester = <
 
 	return make(fixtureIt);
 };
+
+export const makeTrpcTester = <
+	Options,
+	Caller extends object,
+	Provided,
+	LayerError,
+>(
+	fixtureIt: FixtureTestApi<Provided>,
+	options: TrpcTestRuntimeOptions<Options, Caller, Provided, LayerError>,
+): TrpcTester<Options, Caller, Provided> =>
+	makeTrpcHarnessTester(fixtureIt, {
+		...options,
+		makeHarness: (trpc) => Effect.succeed(trpc),
+	}) as TrpcTester<Options, Caller, Provided>;

package/src/procedure.ts

@@ -2,17 +2,20 @@ import type {
 	TRPCMutationProcedure,
 	TRPCProcedureBuilder,
 	TRPCQueryProcedure,
+	TRPCSubscriptionProcedure,
 } from "@trpc/server";
 import { Schema } from "effect";
 import { makeProcedureHandler } from "./internal/procedure-handler.js";
 import type {
 	DefaultValue,
 	EffectProcedureResolver,
+	EffectSubscriptionResolver,
 	IntersectIfDefined,
 	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<
@@ -72,6 +75,8 @@ export class EffectProcedureBuilder<
 			LayerError
 		>,
 		private readonly runtime: RuntimeBridge<RuntimeRequirements>,
+		private readonly subscriptionBuilder = builder,
+		private readonly subscriptionOutput?: Schema.ConstraintDecoder<unknown>,
 	) {}
 
 	input<SchemaValue extends Schema.ConstraintDecoder<unknown>>(
@@ -89,6 +94,9 @@ export class EffectProcedureBuilder<
 		RuntimeRequirements
 	> {
 		const next = this.builder.input(Schema.toStandardSchemaV1(schema) as never);
+		const subscriptionNext = this.subscriptionBuilder.input(
+			Schema.toStandardSchemaV1(schema) as never,
+		);
 		return new EffectProcedureBuilder(
 			next as unknown as Builder<
 				Context,
@@ -101,6 +109,16 @@ export class EffectProcedureBuilder<
 			>,
 			this.requestServices,
 			this.runtime,
+			subscriptionNext as unknown as Builder<
+				Context,
+				Meta,
+				ContextOverrides,
+				IntersectIfDefined<InputIn, SchemaValue["Encoded"]>,
+				IntersectIfDefined<InputOut, SchemaValue["Type"]>,
+				OutputIn,
+				OutputOut
+			>,
+			this.subscriptionOutput,
 		);
 	}
 
@@ -131,6 +149,16 @@ export class EffectProcedureBuilder<
 			>,
 			this.requestServices,
 			this.runtime,
+			this.subscriptionBuilder as unknown as Builder<
+				Context,
+				Meta,
+				ContextOverrides,
+				InputIn,
+				InputOut,
+				IntersectIfDefined<OutputIn, SchemaValue["Encoded"]>,
+				IntersectIfDefined<OutputOut, SchemaValue["Type"]>
+			>,
+			schema,
 		);
 	}
 
@@ -170,6 +198,36 @@ export class EffectProcedureBuilder<
 		}>;
 	}
 
+	subscription<Output>(
+		resolver: EffectSubscriptionResolver<
+			DefaultValue<InputOut, undefined>,
+			ProvidedServices | NoInfer<RuntimeRequirements>,
+			DefaultValue<OutputIn, Output>
+		>,
+	): TRPCSubscriptionProcedure<{
+		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;
+		return this.subscriptionBuilder.subscription(
+			handler,
+		) as TRPCSubscriptionProcedure<{
+			input: DefaultValue<InputIn, void>;
+			output: AsyncIterable<DefaultValue<OutputOut, Output>, void, unknown>;
+			meta: Meta;
+		}>;
+	}
+
 	private dispatch<Output>(
 		type: "mutation" | "query",
 		resolver: EffectProcedureResolver<

package/src/request-signal.ts

@@ -0,0 +1,7 @@
+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 },
+);

package/src/testing/types.ts

@@ -3,45 +3,57 @@ import type { Effect, Layer } from "effect";
 import type { EffectTRPCAdapter } from "../adapter.js";
 import type { EffectCallerFactory } from "./caller.js";
 
-export type TrpcTest<Options, Caller, Provided> = <
+export type TrpcHarnessTest<Harness, Provided> = <
 	A,
 	Eff extends Effect.Effect<unknown, unknown, Provided>,
 >(
 	name: string,
-	body: (
-		trpc: EffectCallerFactory<Options, Caller>,
-		context: TestContext,
-	) => Generator<Eff, A, never>,
+	body: (harness: Harness, 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>;
+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>;
+	readonly only: TrpcHarnessTest<Harness, Provided>;
 	readonly each: <Item>(
 		cases: ReadonlyArray<Item>,
 	) => <A, Eff extends Effect.Effect<unknown, unknown, Provided>>(
 		name: string,
 		body: (
 			item: Item,
-			trpc: EffectCallerFactory<Options, Caller>,
+			harness: Harness,
 			context: TestContext,
 		) => Generator<Eff, A, never>,
 		options?: number | TestOptions,
 	) => void;
-	readonly fails: TrpcTest<Options, Caller, Provided>;
+	readonly fails: TrpcHarnessTest<Harness, 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 TrpcIt<Options, Caller, Provided> = Vitest.Methods & {
 	readonly effectTRPC: TrpcTester<Options, Caller, Provided>;
 };
 
-export interface TrpcTestRuntimeOptions<
+export type TrpcHarnessIt<Harness, Provided> = Vitest.Methods & {
+	readonly effectTRPC: TrpcHarnessTester<Harness, Provided>;
+};
+
+export interface TrpcHarnessTestRuntimeOptions<
 	Options,
 	Caller extends object,
+	Harness,
 	Provided,
 	LayerError,
 > {
@@ -51,8 +63,28 @@ export interface TrpcTestRuntimeOptions<
 	) => Effect.Effect<A, unknown, Provided>;
 	readonly createCaller: (options?: Options) => Caller;
 	readonly layer: Layer.Layer<Provided, LayerError>;
+	readonly makeHarness: (
+		trpc: EffectCallerFactory<Options, Caller>,
+		context: TestContext,
+	) => Effect.Effect<Harness, unknown, Provided>;
 }
 
+export type TrpcTestRuntimeOptions<
+	Options,
+	Caller extends object,
+	Provided,
+	LayerError,
+> = Omit<
+	TrpcHarnessTestRuntimeOptions<
+		Options,
+		Caller,
+		EffectCallerFactory<Options, Caller>,
+		Provided,
+		LayerError
+	>,
+	"makeHarness"
+>;
+
 export interface MakeTrpcItOptions<
 	CreateCaller extends (...arguments_: never[]) => object,
 	// biome-ignore lint/suspicious/noExplicitAny: Layer output and error are recovered with Layer utility types
@@ -66,6 +98,21 @@ export interface MakeTrpcItOptions<
 	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> {
+	readonly makeHarness: (
+		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

package/src/testing/vitest.ts

@@ -1,17 +1,54 @@
-import { it as effectIt } from "@effect/vitest";
+import { it as effectIt, type Vitest } from "@effect/vitest";
 import { Effect, Exit, Layer, Scope } from "effect";
 import {
 	type FixtureTestApi,
 	fixtureName,
+	makeTrpcHarnessTester,
 	makeTrpcTester,
 } from "../internal/vitest-trpc.js";
 import type {
 	CallerOptions,
 	CallerResult,
+	MakeTrpcHarnessItOptions,
 	MakeTrpcItOptions,
+	TrpcHarnessIt,
 	TrpcIt,
 } from "./types.js";
 
+const makeFixtureIt = <Provided, LayerError>(
+	layer: Layer.Layer<Provided, LayerError>,
+): FixtureTestApi<Provided> =>
+	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(layer, scope));
+			} catch (error) {
+				await Effect.runPromise(Scope.close(scope, Exit.void));
+				throw error;
+			}
+		},
+	) as unknown as FixtureTestApi<Provided>;
+
+const withEffectTRPC = <Tester>(
+	tester: Tester,
+): Vitest.Methods & {
+	readonly effectTRPC: Tester;
+} =>
+	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 makeTrpcIt = <
 	CreateCaller extends (...arguments_: never[]) => object,
 	// biome-ignore lint/suspicious/noExplicitAny: Layer output and error are recovered with Layer utility types
@@ -27,23 +64,8 @@ export const makeTrpcIt = <
 	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 fixtureIt = makeFixtureIt<Provided, Layer.Error<TestLayer>>(
+		options.layer,
 	);
 
 	const effectTRPC = makeTrpcTester(
@@ -53,12 +75,36 @@ export const makeTrpcIt = <
 		>[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>;
+	return withEffectTRPC(effectTRPC) as TrpcIt<Options, Caller, Provided>;
+};
+
+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,
+>(
+	options: MakeTrpcHarnessItOptions<CreateCaller, TestLayer, Harness>,
+): TrpcHarnessIt<Harness, Layer.Success<TestLayer>> => {
+	type Options = CallerOptions<CreateCaller>;
+	type Caller = CallerResult<CreateCaller>;
+	type Provided = Layer.Success<TestLayer>;
+
+	const fixtureIt = makeFixtureIt<Provided, Layer.Error<TestLayer>>(
+		options.layer,
+	);
+	const effectTRPC = makeTrpcHarnessTester(
+		fixtureIt,
+		options as unknown as Parameters<
+			typeof makeTrpcHarnessTester<
+				Options,
+				Caller,
+				Harness,
+				Provided,
+				Layer.Error<TestLayer>
+			>
+		>[1],
+	);
+
+	return withEffectTRPC(effectTRPC);
 };

package/src/testing.ts

@@ -5,9 +5,15 @@ export {
 	makeEffectCallerFactory,
 } from "./testing/caller.js";
 export type {
+	CallerOptions,
+	CallerResult,
+	MakeTrpcHarnessItOptions,
 	MakeTrpcItOptions,
+	TrpcHarnessIt,
+	TrpcHarnessTest,
+	TrpcHarnessTester,
 	TrpcIt,
 	TrpcTest,
 	TrpcTester,
 } from "./testing/types.js";
-export { makeTrpcIt } from "./testing/vitest.js";
+export { makeTrpcHarnessIt, makeTrpcIt } from "./testing/vitest.js";

package/src/types.ts

@@ -1,7 +1,7 @@
 import type { TRPCError } from "@trpc/server";
-import type { Effect } from "effect";
+import type { Effect, Stream } from "effect";
 
-export type ProcedureKind = "mutation" | "query";
+export type ProcedureKind = "mutation" | "query" | "subscription";
 
 export interface ProcedureInfo {
 	readonly captureStackTrace: () => string | undefined;
@@ -22,3 +22,8 @@ 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>;