@shivaedev/effect-trpc 0.3.4 → 0.4.1

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>
-	>;
+	});

package/src/testing.ts

@@ -3,7 +3,7 @@ export {
 	type EffectCallerFactory,
 	makeEffectCaller,
 	makeEffectCallerFactory,
-} from "./testing/caller.js";
+} from "./testing/caller.ts";
 export type {
 	CallerOptions,
 	CallerResult,
@@ -15,5 +15,5 @@ export type {
 	TrpcIt,
 	TrpcTest,
 	TrpcTester,
-} from "./testing/types.js";
-export { makeTrpcHarnessIt, makeTrpcIt } from "./testing/vitest.js";
+} from "./testing/types.ts";
+export { makeTrpcHarnessIt, makeTrpcIt } from "./testing/vitest.ts";

package/src/types.ts

@@ -13,17 +13,8 @@ export interface EffectTRPCErrorContext extends ProcedureInfo {
 	readonly origin: "defect" | "failure";
 }
 
-export type EffectTRPCErrorMapper = (
-	error: unknown,
-	context: EffectTRPCErrorContext,
-) => TRPCError | undefined;
+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 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>;
+export type EffectTRPCStreamInstrument = <A, E, R>(stream: Stream.Stream<A, E, R>, procedure: ProcedureInfo) => Stream.Stream<A, E, R>;