@shivaedev/platform 0.0.0 → 0.2.0

package/src/runtime/types.ts

@@ -0,0 +1,34 @@
+import type { Context, Effect, Exit } from "effect";
+
+export interface PlatformRuntimeOptions {
+	/** Reuse one runtime across development module reloads. */
+	readonly developmentCacheKey?: string | symbol;
+}
+
+export interface PlatformRuntime<Services, BuildError> {
+	readonly contextEffect: Effect.Effect<Context.Context<Services>, BuildError>;
+	readonly currentServices: () => Context.Context<never> | undefined;
+	readonly dispose: () => Promise<void>;
+	readonly runPromise: <A, E, Requirements extends Services>(
+		effect: Effect.Effect<A, E, Requirements>,
+		options?: { readonly signal?: AbortSignal },
+	) => Promise<A>;
+	readonly runPromiseExit: <A, E, Requirements extends Services>(
+		effect: Effect.Effect<A, E, Requirements>,
+		options?: { readonly signal?: AbortSignal },
+	) => Promise<Exit.Exit<A, E | BuildError>>;
+	readonly runWithServices: <Provided, Value>(
+		services: Context.Context<Provided>,
+		evaluate: () => Value,
+	) => Value;
+}
+
+export type PlatformRuntimeServices<Runtime> =
+	Runtime extends PlatformRuntime<infer Services, infer _BuildError>
+		? Services
+		: never;
+
+export type PlatformRuntimeBuildError<Runtime> =
+	Runtime extends PlatformRuntime<infer _Services, infer BuildError>
+		? BuildError
+		: never;

package/src/runtime.ts

@@ -0,0 +1,7 @@
+export { makePlatformRuntime } from "./runtime/make.js";
+export type {
+	PlatformRuntime,
+	PlatformRuntimeBuildError,
+	PlatformRuntimeOptions,
+	PlatformRuntimeServices,
+} from "./runtime/types.js";

package/src/testing/types.ts

@@ -0,0 +1,71 @@
+import type { TestContext, Vitest } from "@effect/vitest";
+import type {
+	AnyDatabase,
+	DatabaseRequirement,
+	DatabaseService,
+} from "@shivaedev/effect-prisma/testing";
+import type { EffectTRPCAdapter } from "@shivaedev/effect-trpc";
+import type {
+	CallerOptions,
+	CallerResult,
+	EffectCallerFactory,
+	TrpcHarnessTest,
+	TrpcHarnessTester,
+} from "@shivaedev/effect-trpc/testing";
+import type { Effect, Layer } from "effect";
+
+export type PlatformHarness<
+	Database extends AnyDatabase,
+	Options,
+	Caller,
+	Extension,
+> = Readonly<{
+	db: DatabaseService<Database>;
+	trpc: EffectCallerFactory<Options, Caller>;
+}> &
+	Readonly<{
+		promise: <Value>(
+			evaluate: () => Promise<Value>,
+		) => Effect.Effect<Value, unknown>;
+	}> &
+	Omit<Extension, "db" | "promise" | "trpc">;
+
+export type PlatformTest<Harness, Provided> = TrpcHarnessTest<
+	Harness,
+	Provided
+>;
+
+export type PlatformTester<Harness, Provided> = TrpcHarnessTester<
+	Harness,
+	Provided
+>;
+
+export type PlatformIt<Harness, Provided> = Vitest.Methods & {
+	readonly effectApp: PlatformTester<Harness, Provided>;
+};
+
+export interface MakePlatformItOptions<
+	Database extends AnyDatabase,
+	CreateCaller extends (...arguments_: never[]) => object,
+	Provided,
+	LayerError,
+	Extension,
+> {
+	readonly adapter: Pick<EffectTRPCAdapter<never>, "runWithServices">;
+	readonly createCaller: CreateCaller;
+	readonly extend?: (
+		base: Readonly<{
+			db: DatabaseService<Database>;
+			trpc: EffectCallerFactory<
+				CallerOptions<NoInfer<CreateCaller>>,
+				CallerResult<NoInfer<CreateCaller>>
+			>;
+		}>,
+		context: TestContext,
+	) => Effect.Effect<
+		Extension,
+		unknown,
+		Provided | DatabaseRequirement<Database> | Effect.Services<Database>
+	>;
+	readonly layer: Layer.Layer<Provided, LayerError>;
+}

package/src/testing/vitest.ts

@@ -0,0 +1,100 @@
+import type { Vitest } from "@effect/vitest";
+import {
+	type AnyDatabase,
+	type DatabaseRequirement,
+	type DatabaseService,
+	withTestTransaction,
+} from "@shivaedev/effect-prisma/testing";
+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";
+
+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 | DatabaseRequirement<Database> | Effect.Services<Database>,
+				LayerError
+			>;
+		},
+	): PlatformIt<
+		PlatformHarness<
+			Database,
+			CallerOptions<CreateCaller>,
+			CallerResult<CreateCaller>,
+			Extension
+		>,
+		Provided | DatabaseRequirement<Database> | Effect.Services<Database>
+	> => {
+		type Options = CallerOptions<CreateCaller>;
+		type Caller = CallerResult<CreateCaller>;
+		type Services =
+			| Provided
+			| DatabaseRequirement<Database>
+			| 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>;
+	};

package/src/testing.ts

@@ -0,0 +1,8 @@
+export type {
+	MakePlatformItOptions,
+	PlatformHarness,
+	PlatformIt,
+	PlatformTest,
+	PlatformTester,
+} from "./testing/types.js";
+export { makePlatformIt } from "./testing/vitest.js";