@shivaedev/platform 0.3.8 → 0.4.0

package/src/testing/vitest.ts

@@ -1,96 +1,66 @@
-import type { Vitest } from "@effect/vitest";
-import {
-	type AnyDatabase,
-	type DatabaseService,
-	withTestTransaction,
-} from "@shivaedev/effect-prisma/testing";
-import {
-	type CallerOptions,
-	type CallerResult,
-	type EffectCallerFactory,
-	makeTrpcHarnessIt,
-} from "@shivaedev/effect-trpc/testing";
+import type { TestContext } from "@effect/vitest";
+import { type AnyDatabase, withTestTransaction } from "@shivaedev/effect-prisma/testing";
+import type { EffectTRPCAdapter } from "@shivaedev/effect-trpc";
+import { type CallerOptions, type CallerResult, type EffectCallerFactory, makeTrpcHarnessIt } from "@shivaedev/effect-trpc/testing";
 import { Effect, type Layer } from "effect";
-import type {
-	MakePlatformItOptions,
-	PlatformHarness,
-	PlatformIt,
-} from "./types.js";
+import type { MakePlatformItOptions, PlatformHarness, PlatformIt } from "./types.ts";
+
+interface LooseOptions {
+	readonly adapter: Pick<EffectTRPCAdapter<never>, "runWithServices">;
+	readonly createCaller: (options?: unknown) => object;
+	extend?(
+		base: { readonly db: unknown; readonly trpc: EffectCallerFactory<unknown, object> },
+		context: TestContext,
+	): Effect.Effect<object, unknown, unknown>;
+	readonly layer: Layer.Layer<unknown, unknown>;
+}
+
+function platformIt<
+	Database extends AnyDatabase,
+	CreateCaller extends (...arguments_: never[]) => object,
+	Provided,
+	LayerError,
+	Extension extends object,
+>(
+	database: Database,
+	options: MakePlatformItOptions<Database, CreateCaller, Provided, LayerError, Extension> & {
+		readonly layer: Layer.Layer<Provided | Effect.Services<Database>, LayerError>;
+	},
+): PlatformIt<PlatformHarness<Database, CallerOptions<CreateCaller>, CallerResult<CreateCaller>, Extension>, Provided | Effect.Services<Database>>;
+function platformIt(database: AnyDatabase, options: LooseOptions): unknown {
+	const trpcIt = makeTrpcHarnessIt({
+		adapter: options.adapter,
+		createCaller: options.createCaller,
+		layer: options.layer,
+		around: (effect) => withTestTransaction(database, effect),
+		makeHarness: (trpc, context) =>
+			Effect.gen(function* () {
+				const services = yield* Effect.context<unknown>();
+				const db = yield* database;
+				const extension = options.extend ? yield* options.extend({ db, trpc }, context) : {};
+				const promise = <Value>(evaluate: () => Promise<Value>) => Effect.tryPromise(() => options.adapter.runWithServices(services, evaluate));
+				return { ...extension, db, promise, trpc };
+			}),
+	});
+
+	return new Proxy(trpcIt, {
+		get(target, property, receiver) {
+			if (property === "effectApp") {
+				return trpcIt.effectTRPC;
+			}
+			return Reflect.get(target, property, receiver);
+		},
+	});
+}
 
 export const makePlatformIt =
 	<const Database extends AnyDatabase>(database: Database) =>
-	<
-		CreateCaller extends (...arguments_: never[]) => object,
-		Provided,
-		LayerError,
-		Extension extends object = Record<never, never>,
-	>(
-		options: MakePlatformItOptions<
-			Database,
-			CreateCaller,
-			Provided,
-			LayerError,
-			Extension
-		> & {
-			readonly layer: Layer.Layer<
-				Provided | Effect.Services<Database>,
-				LayerError
-			>;
+	<CreateCaller extends (...arguments_: never[]) => object, Provided, LayerError, Extension extends object = Record<never, never>>(
+		options: MakePlatformItOptions<Database, CreateCaller, Provided, LayerError, Extension> & {
+			readonly layer: Layer.Layer<Provided | Effect.Services<Database>, LayerError>;
 		},
 	): PlatformIt<
-		PlatformHarness<
-			Database,
-			CallerOptions<CreateCaller>,
-			CallerResult<CreateCaller>,
-			Extension
-		>,
+		PlatformHarness<Database, CallerOptions<CreateCaller>, CallerResult<CreateCaller>, Extension>,
 		Provided | Effect.Services<Database>
-	> => {
-		type Options = CallerOptions<CreateCaller>;
-		type Caller = CallerResult<CreateCaller>;
-		type Services = Provided | Effect.Services<Database>;
-		type Harness = PlatformHarness<Database, Options, Caller, Extension>;
-
-		const trpcIt = makeTrpcHarnessIt<
-			CreateCaller,
-			Layer.Layer<Services, LayerError>,
-			Harness
-		>({
-			adapter: options.adapter,
-			createCaller: options.createCaller,
-			layer: options.layer,
-			around: (effect) => withTestTransaction(database, effect),
-			makeHarness: (
-				trpc: EffectCallerFactory<Options, Caller>,
-				context,
-			): Effect.Effect<Harness, unknown, Services> =>
-				Effect.gen(function* () {
-					const services = yield* Effect.context<Services>();
-					const databaseEffect = database as unknown as Effect.Effect<
-						DatabaseService<Database>,
-						never,
-						Effect.Services<Database>
-					>;
-					const db = yield* databaseEffect;
-					const extension = options.extend
-						? yield* options.extend({ db, trpc }, context)
-						: ({} as Extension);
-					const promise = <Value>(evaluate: () => Promise<Value>) =>
-						Effect.tryPromise(() =>
-							options.adapter.runWithServices(services, evaluate),
-						);
-					return { ...extension, db, promise, trpc } as Harness;
-				}) as Effect.Effect<Harness, unknown, Services>,
-		});
-
-		return new Proxy(trpcIt, {
-			get(target, property, receiver) {
-				if (property === "effectApp") {
-					return trpcIt.effectTRPC;
-				}
-				return Reflect.get(target, property, receiver);
-			},
-		}) as unknown as Vitest.Methods & {
-			readonly effectApp: typeof trpcIt.effectTRPC;
-		} as PlatformIt<Harness, Services>;
-	};
+	> =>
+		platformIt(database, options);

package/src/testing.ts

@@ -4,5 +4,5 @@ export type {
 	PlatformIt,
 	PlatformTest,
 	PlatformTester,
-} from "./testing/types.js";
-export { makePlatformIt } from "./testing/vitest.js";
+} from "./testing/types.ts";
+export { makePlatformIt } from "./testing/vitest.ts";